lightning 5.3.0 → 5.3.1

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Versions
 
-## 5.3.0
+## 5.3.1
 
 - `getInvoices`: Add `is_unconfirmed` to filter out canceled/settled invoices
 

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/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/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/package.json

@@ -57,5 +57,5 @@
     "directory": "test/typescript"
   },
   "types": "index.d.ts",
-  "version": "5.3.0"
+  "version": "5.3.1"
 }

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