lightning 5.2.1 → 5.3.3

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Versions
 
+## 5.3.3
+
+- `pay`, `payViaPaymentRequest`: Fix support for `outgoing_channels` constraint
+
+## 5.3.1
+
+- `getInvoices`: Add `is_unconfirmed` to filter out canceled/settled invoices
+
 ## 5.2.1
 
 - `getPendingChannels`: Add support for channel `capacity`

package/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2019-2021 Alex Bosworth
+Copyright (c) 2019-2022 Alex Bosworth
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -15,6 +15,7 @@ Methods for working with the Lightning Network
 - [Thunderhub](https://www.thunderhub.io/) - https://github.com/apotdevin/thunderhub
 - [Lightning Roulette](https://lightning-roulette.com/) - https://github.com/igreshev/lightning-roulette
 - [Lightning Poker](https://lightning-poker.com/) - https://github.com/igreshev/lightning-poker
+- [p2plnbot](https://telegram.me/lnp2pbot) - https://github.com/grunch/p2plnbot
 - [rekr](https://rekr.app/) - https://github.com/ryan-lingle/rekr
 - [Suredbits API](https://suredbits.com/) - https://github.com/Suredbits/sb-api-lnd
 

package/index.js

@@ -17,6 +17,7 @@ const {deleteFailedPayments} = require('./lnd_methods');
 const {deleteForwardingReputations} = require('./lnd_methods');
 const {deletePayment} = require('./lnd_methods');
 const {deletePayments} = require('./lnd_methods');
+const {deletePendingChannel} = require('./lnd_methods');
 const {diffieHellmanComputeSecret} = require('./lnd_methods');
 const {disableChannel} = require('./lnd_methods');
 const {disconnectWatchtower} = require('./lnd_methods');
@@ -153,6 +154,7 @@ module.exports = {
   deleteForwardingReputations,
   deletePayment,
   deletePayments,
+  deletePendingChannel,
   disableChannel,
   disconnectWatchtower,
   enableChannel,

package/lnd_methods/index.js

@@ -16,6 +16,7 @@ const {deleteFailedPayments} = require('./offchain');
 const {deleteForwardingReputations} = require('./offchain');
 const {deletePayment} = require('./offchain');
 const {deletePayments} = require('./offchain');
+const {deletePendingChannel} = require('./offchain');
 const {diffieHellmanComputeSecret} = require('./signer');
 const {disableChannel} = require('./offchain');
 const {disconnectWatchtower} = require('./offchain');
@@ -148,6 +149,7 @@ module.exports = {
   deleteForwardingReputations,
   deletePayment,
   deletePayments,
+  deletePendingChannel,
   diffieHellmanComputeSecret,
   disableChannel,
   disconnectWatchtower,

package/lnd_methods/invoices/get_invoices.js

@@ -28,6 +28,7 @@ const type = 'default';
   Invoice `payment` is not supported on LND 0.11.1 and below
 
   {
+    [is_unconfirmed]: <Omit Canceled and Settled Invoices Bool>
     [limit]: <Page Result Limit Number>
     lnd: <Authenticated LND API Object>
     [token]: <Opaque Paging Token String>
@@ -87,16 +88,16 @@ const type = 'default';
     [next]: <Next Opaque Paging Token String>
   }
 */
-module.exports = ({limit, lnd, token}, cbk) => {
+module.exports = (args, cbk) => {
   return new Promise((resolve, reject) => {
     return asyncAuto({
       // Validate arguments
       validate: cbk => {
-        if (!!limit && !!token) {
+        if (!!args.limit && !!args.token) {
           return cbk([400, 'UnexpectedLimitWhenPagingInvoicesWithToken']);
         }
 
-        if (!isLnd({lnd, method, type})) {
+        if (!isLnd({method, type, lnd: args.lnd})) {
           return cbk([400, 'ExpectedLndForInvoiceListing']);
         }
 
@@ -106,12 +107,12 @@ module.exports = ({limit, lnd, token}, cbk) => {
       // Get the list of invoices
       listInvoices: ['validate', ({}, cbk) => {
         let offset;
-        let resultsLimit = limit || defaultLimit;
+        let resultsLimit = args.limit || defaultLimit;
 
         // When there is a token, parse it out into an offset and a limit
-        if (!!token) {
+        if (!!args.token) {
           try {
-            const pagingToken = parse(token);
+            const pagingToken = parse(args.token);
 
             offset = pagingToken.offset;
             resultsLimit = pagingToken.limit;
@@ -121,9 +122,10 @@ module.exports = ({limit, lnd, token}, cbk) => {
         }
 
         return asyncRetry({}, cbk => {
-          return lnd[type][method]({
+          return args.lnd[type][method]({
             index_offset: offset || Number(),
             num_max_invoices: resultsLimit,
+            pending_only: args.is_unconfirmed === true || undefined,
             reversed: true,
           },
           (err, res) => {

package/lnd_methods/macaroon/methods.json

@@ -63,6 +63,10 @@
     "method": "DeleteAllPayments",
     "type": "default"
   },
+  "deletePendingChannel": {
+    "method": "AbandonChannel",
+    "type": "default"
+  },
   "diffieHellmanComputeSecret": {
     "method": "DeriveSharedKey",
     "type": "signer"

package/lnd_methods/offchain/delete_pending_channel.js

@@ -0,0 +1,109 @@
+const asyncAuto = require('async/auto');
+const {returnResult} = require('asyncjs-util');
+const {Transaction} = require('bitcoinjs-lib');
+
+const {fromHex} = Transaction;
+const method = 'abandonChannel';
+const txIdAsHash = id => Buffer.from(id, 'hex').reverse();
+const type = 'default';
+
+/** Delete a pending channel
+
+  Pass the confirmed conflicting transaction that spends the same input to
+  make sure that no funds are being deleted.
+
+  This method is not supported on LND 0.13.3 and below
+
+  {
+    confirmed_transaction: <Hex Encoded Conflicting Transaction String>
+    lnd: <Authenticated LND API Object>
+    pending_transaction: <Hex Encoded Pending Transaction String>
+    pending_transaction_vout: <Pending Channel Output Index Number>
+  }
+
+  @returns via cbk or Promise
+*/
+module.exports = (args, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!args.confirmed_transaction) {
+          return cbk([400, 'ExpectedConfirmedConflictingTxToDeleteChannel']);
+        }
+
+        try {
+          fromHex(args.confirmed_transaction);
+        } catch (err) {
+          return cbk([400, 'ExpectedValidConfirmedTxToDeleteChannel']);
+        }
+
+        if (args.confirmed_transaction === args.pending_transaction) {
+          return cbk([400, 'ExpectedConflictingTransactionToDeleteChannel']);
+        }
+
+        if (!args.lnd) {
+          return cbk([400, 'ExpectedAuthenticatedLndToDeleteChannel']);
+        }
+
+        if (!args.pending_transaction) {
+          return cbk([400, 'ExpectedPendingTransactionToDeleteChannel']);
+        }
+
+        try {
+          fromHex(args.pending_transaction);
+        } catch (err) {
+          return cbk([400, 'ExpectedValidPendingTxToDeleteChannel']);
+        }
+
+        if (args.pending_transaction_vout === undefined) {
+          return cbk([400, 'ExpectedPendingChannelTxVoutToDeleteChannel']);
+        }
+
+        return cbk();
+      },
+
+      // Check for a conflicting input between the confirmed and pending txs
+      transactionId: ['validate', ({}, cbk) => {
+        const confirmedInputs = fromHex(args.confirmed_transaction).ins;
+        const pending = fromHex(args.pending_transaction);
+
+        const conflictingInput = pending.ins.find(pendingInput => {
+          return confirmedInputs.find(confirmedInput => {
+            if (!confirmedInput.hash.equals(pendingInput.hash)) {
+              return false;
+            }
+
+            return confirmedInput.index === pendingInput.index;
+          });
+        });
+
+        if (!conflictingInput) {
+          return cbk([400, 'FailedToFindConflictingInputInConfirmedTx']);
+        }
+
+        // The pending transaction conflicts with the confirmed transaction
+        return cbk(null, pending.getId());
+      }],
+
+      // Delete the channel
+      abandonChannel: ['transactionId', ({transactionId}, cbk) => {
+        return args.lnd[type][method]({
+          channel_point: {
+            funding_txid_bytes: txIdAsHash(transactionId),
+            output_index: args.pending_transaction_vout,
+          },
+          i_know_what_i_am_doing: true,
+        },
+        err => {
+          if (!!err) {
+            return cbk([503, 'UnexpectedErrorDeletingPendingChannel', {err}]);
+          }
+
+          return cbk();
+        });
+      }],
+    },
+    returnResult({reject, resolve}, cbk));
+  });
+};

package/lnd_methods/offchain/index.js

@@ -5,6 +5,7 @@ const deleteFailedPayments = require('./delete_failed_payments');
 const deleteForwardingReputations = require('./delete_forwarding_reputations');
 const deletePayment = require('./delete_payment');
 const deletePayments = require('./delete_payments');
+const deletePendingChannel = require('./delete_pending_channel');
 const disableChannel = require('./disable_channel');
 const disconnectWatchtower = require('./disconnect_watchtower');
 const enableChannel = require('./enable_channel');
@@ -59,6 +60,7 @@ module.exports = {
   deleteForwardingReputations,
   deletePayment,
   deletePayments,
+  deletePendingChannel,
   disableChannel,
   disconnectWatchtower,
   enableChannel,

package/lnd_methods/offchain/pay_via_payment_request.js

@@ -99,6 +99,7 @@ module.exports = (args, cbk) => {
           messages: args.messages,
           mtokens: args.mtokens,
           outgoing_channel: args.outgoing_channel,
+          outgoing_channels: args.outgoing_channels,
           pathfinding_timeout: args.pathfinding_timeout,
           request: args.request,
           tokens: args.tokens,

package/lnd_methods/onchain/open_channels.d.ts

@@ -19,8 +19,6 @@ export type OpenChannelsArgs = AuthenticatedLightningArgs<{
     partner_public_key: string;
     /** Peer Output CSV Delay */
     partner_csv_delay?: number;
-    /** Peer Connection Host:Port */
-    partner_socket?: string;
   }[];
   /** Do not broadcast any channel funding transactions */
   is_avoiding_broadcast?: boolean;

package/lnd_methods/onchain/open_channels.js

@@ -41,7 +41,6 @@ const type = 'default';
       [min_htlc_mtokens]: <Minimum HTLC Millitokens String>
       [partner_csv_delay]: <Peer Output CSV Delay Number>
       partner_public_key: <Public Key Hex String>
-      [partner_socket]: <Peer Connection Host:Port String>
     }]
     [is_avoiding_broadcast]: <Avoid Broadcast of All Channels Bool>
     lnd: <Authenticated LND API Object>
@@ -95,7 +94,6 @@ module.exports = (args, cbk) => {
           min_htlc_mtokens: channel.min_htlc_mtokens,
           partner_public_key: channel.partner_public_key,
           partner_csv_delay: channel.partner_csv_delay,
-          partner_socket: channel.partner_socket,
         })));
       }],
 

package/lnd_methods/unauthenticated/create_wallet.js

@@ -3,6 +3,8 @@ const {returnResult} = require('asyncjs-util');
 
 const {isLnd} = require('./../../lnd_requests');
 
+const bufferAsBase64 = buffer => buffer.toString('base64');
+const {isBuffer} = Buffer;
 const method = 'initWallet';
 const type = 'unlocker';
 const utf8AsBuf = utf8 => Buffer.from(utf8, 'utf8');
@@ -19,6 +21,9 @@ const utf8AsBuf = utf8 => Buffer.from(utf8, 'utf8');
   }
 
   @returns via cbk or Promise
+  {
+    macaroon: <Base64 Encoded Admin Macaroon String>
+  }
 */
 module.exports = ({lnd, passphrase, password, seed}, cbk) => {
   return new Promise((resolve, reject) => {
@@ -47,12 +52,20 @@ module.exports = ({lnd, passphrase, password, seed}, cbk) => {
           cipher_seed_mnemonic: seed.split(' '),
           wallet_password: utf8AsBuf(password),
         },
-        err => {
+        (err, res) => {
           if (!!err) {
             return cbk([503, 'UnexpectedInitWalletError', {err}]);
           }
 
-          return cbk();
+          if (!res) {
+            return cbk([503, 'ExpectedResponseForInitWallet']);
+          }
+
+          if (!isBuffer(res.admin_macaroon)) {
+            return cbk([503, 'ExpectedAdminMacaroonToCrateWallet']);
+          }
+
+          return cbk(null, bufferAsBase64(res.admin_macaroon));
         });
       }],
     },

package/package.json

@@ -7,32 +7,32 @@
     "url": "https://github.com/alexbosworth/lightning/issues"
   },
   "dependencies": {
-    "@grpc/grpc-js": "1.4.4",
-    "@grpc/proto-loader": "0.6.7",
+    "@grpc/grpc-js": "1.5.1",
+    "@grpc/proto-loader": "0.6.9",
     "@types/express": "4.17.13",
-    "@types/node": "16.11.12",
-    "@types/request": "2.48.7",
+    "@types/node": "17.0.8",
+    "@types/request": "2.48.8",
     "@types/ws": "8.2.2",
-    "async": "3.2.2",
-    "asyncjs-util": "1.2.7",
+    "async": "3.2.3",
+    "asyncjs-util": "1.2.8",
     "bitcoinjs-lib": "6.0.1",
     "bn.js": "5.2.0",
-    "body-parser": "1.19.0",
-    "bolt07": "1.7.4",
-    "bolt09": "0.2.0",
+    "body-parser": "1.19.1",
+    "bolt07": "1.8.0",
+    "bolt09": "0.2.1",
     "cbor": "8.1.0",
-    "express": "4.17.1",
-    "invoices": "2.0.2",
+    "express": "4.17.2",
+    "invoices": "2.0.3",
     "psbt": "1.1.10",
-    "type-fest": "2.8.0"
+    "type-fest": "2.9.0"
   },
   "description": "Lightning Network client library",
   "devDependencies": {
     "@alexbosworth/node-fetch": "2.6.2",
     "@alexbosworth/tap": "15.0.10",
-    "tsd": "0.19.0",
-    "typescript": "4.5.2",
-    "ws": "8.3.0"
+    "tsd": "0.19.1",
+    "typescript": "4.5.4",
+    "ws": "8.4.2"
   },
   "engines": {
     "node": ">=12.20"
@@ -57,5 +57,5 @@
     "directory": "test/typescript"
   },
   "types": "index.d.ts",
-  "version": "5.2.1"
+  "version": "5.3.3"
 }

package/test/lnd_methods/offchain/test_delete_pending_channel.js

@@ -0,0 +1,91 @@
+const {test} = require('@alexbosworth/tap');
+const {Transaction} = require('bitcoinjs-lib');
+
+const {deletePendingChannel} = require('./../../../lnd_methods');
+
+const tx1 = new Transaction();
+const tx2 = new Transaction();
+const tx3 = new Transaction();
+
+tx1.addInput(Buffer.alloc(32, 0), 0);
+tx2.addInput(Buffer.alloc(32, 0), 0);
+tx2.addInput(Buffer.alloc(32, 1), 0);
+tx2.addOutput(Buffer.alloc(10), 1);
+tx3.addInput(Buffer.alloc(32, 2), 0);
+
+const makeArgs = overrides => {
+  const args = {
+    confirmed_transaction: tx1.toHex(),
+    lnd: {default: {abandonChannel: ({}, cbk) => cbk()}},
+    pending_transaction: tx2.toHex(),
+    pending_transaction_vout: 0,
+  };
+
+  Object.keys(overrides).forEach(k => args[k] = overrides[k]);
+
+  return args;
+};
+
+const tests = [
+  {
+    args: makeArgs({confirmed_transaction: undefined}),
+    description: 'A conflicting confirmed tx is required',
+    error: [400, 'ExpectedConfirmedConflictingTxToDeleteChannel'],
+  },
+  {
+    args: makeArgs({confirmed_transaction: 'confirmed transaction'}),
+    description: 'A valid conflicting confirmed tx is required',
+    error: [400, 'ExpectedValidConfirmedTxToDeleteChannel'],
+  },
+  {
+    args: makeArgs({confirmed_transaction: tx2.toHex()}),
+    description: 'Pending transaction must be different from confirmed tx',
+    error: [400, 'ExpectedConflictingTransactionToDeleteChannel'],
+  },
+  {
+    args: makeArgs({lnd: undefined}),
+    description: 'Lnd is required',
+    error: [400, 'ExpectedAuthenticatedLndToDeleteChannel'],
+  },
+  {
+    args: makeArgs({pending_transaction: undefined}),
+    description: 'A pending tx is required',
+    error: [400, 'ExpectedPendingTransactionToDeleteChannel'],
+  },
+  {
+    args: makeArgs({pending_transaction: 'pending transaction'}),
+    description: 'A valid pending tx is required',
+    error: [400, 'ExpectedValidPendingTxToDeleteChannel'],
+  },
+  {
+    args: makeArgs({pending_transaction_vout: undefined}),
+    description: 'A pending tx output index is required',
+    error: [400, 'ExpectedPendingChannelTxVoutToDeleteChannel'],
+  },
+  {
+    args: makeArgs({confirmed_transaction: tx3.toHex()}),
+    description: 'A conflicting tx is required',
+    error: [400, 'FailedToFindConflictingInputInConfirmedTx'],
+  },
+  {
+    args: makeArgs({lnd: {default: {abandonChannel: ({}, cbk) => cbk('er')}}}),
+    description: 'A server error is passed back',
+    error: [503, 'UnexpectedErrorDeletingPendingChannel', {err: 'er'}],
+  },
+  {
+    args: makeArgs({}),
+    description: 'A pending channel is deleted',
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, async ({deepEqual, end, equal, rejects}) => {
+    if (!!error) {
+      await rejects(() => deletePendingChannel(args), error, 'Got error');
+    } else {
+      await deletePendingChannel(args);
+    }
+
+    return end();
+  });
+});

package/test/lnd_methods/unauthenticated/test_create_wallet.js

@@ -30,7 +30,13 @@ const tests = [
   },
   {
     args: {
-      lnd: {unlocker: {initWallet: ({}, cbk) => cbk()}},
+      lnd: {
+        unlocker: {
+          initWallet: ({}, cbk) => cbk(null, {
+            admin_macaroon: Buffer.alloc(1),
+          }),
+        },
+      },
       password: 'pass',
       seed: 'seed',
     },