lightning 10.9.2 → 10.10.1

package/lnd_methods/onchain/request_batched_fee_increase.js

@@ -0,0 +1,108 @@
+const asyncAuto = require('async/auto');
+const {returnResult} = require('asyncjs-util');
+
+const {getHeight} = require('./../generic');
+const {isLnd} = require('./../../lnd_requests');
+
+const defaultTargetConfirmations = 1008;
+const isHash = n => /^[0-9A-F]{64}$/i.test(n);
+const isNumber = n => !isNaN(n);
+const messageExternalUtxo = 'the passed output does not belong to the wallet';
+const method = 'bumpFee';
+const positive = number => number > 0 ? number : 1;
+const type = 'wallet';
+
+/** Request batched CPFP fee bumping of an unconfirmed outpoint on a deadline
+
+  Requires `onchain:write` permission
+
+  Requires LND built with `walletrpc` build tag
+
+  This method is unsupported on LND 0.17.5 and below
+
+  {
+    lnd: <Authenticated LND API Object>
+    [max_fee]: <Maximum Tokens to Pay Into Chain Fees Number>
+    [max_height]: <Maximum Height To Reach a Confirmation Number>
+    transaction_id: <Unconfirmed UTXO Transaction Id Hex String>
+    transaction_vout: <Unconfirmed UTXO Transaction Index Number>
+  }
+
+  @returns via cbk or Promise
+*/
+module.exports = (args, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!isLnd({method, type, lnd: args.lnd})) {
+          return cbk([400, 'ExpectedLndToRequestChainFeeIncrease']);
+        }
+
+        if (!isHash(args.transaction_id)) {
+          return cbk([400, 'ExpectedTransactionIdToRequestChainFeeIncrease']);
+        }
+
+        if (!isNumber(args.transaction_vout)) {
+          return cbk([400, 'ExpectedTransactionOutputIndexToRequestFeeBump']);
+        }
+
+        return cbk();
+      },
+
+      // Get the current height to adjust max height to a conf target delta
+      getHeight: ['validate', ({}, cbk) => {
+        // Exit early when there is no max height specified
+        if (!args.max_height) {
+          return cbk();
+        }
+
+        return getHeight({lnd: args.lnd}, cbk);
+      }],
+
+      // Determine the confirmation target
+      targetConf: ['getHeight', ({getHeight}, cbk) => {
+        // Exit early when there is no max height
+        if (!getHeight) {
+          return cbk(null, defaultTargetConfirmations);
+        }
+
+        const currentBlockHeight = getHeight.current_block_height;
+
+        return cbk(null, positive(args.max_height - currentBlockHeight));
+      }],
+
+      // Make the request to submit the input to the batch sweeper
+      request: ['targetConf', ({targetConf}, cbk) => {
+        return args.lnd[type][method]({
+          budget: args.max_fee,
+          outpoint: {
+            output_index: args.transaction_vout,
+            txid_str: args.transaction_id,
+          },
+          target_conf: targetConf,
+        },
+        (err, res) => {
+          if (!!err && err.details === messageExternalUtxo) {
+            return cbk([404, 'SpecifiedUtxoNotFoundInWalletUtxos']);
+          }
+
+          if (!!err) {
+            return cbk([503, 'UnexpectedErrorRequestingBatchIncrease', {err}]);
+          }
+
+          if (!res) {
+            return cbk([503, 'ExpectedResponseToBatchedFeeIncreaseRequest']);
+          }
+
+          if (res.status === undefined) {
+            return cbk([503, 'ExpectedStatusOfBatchedFeeIncrease']);
+          }
+
+          return cbk();
+        });
+      }],
+    },
+    returnResult({reject, resolve}, cbk));
+  });
+};

package/lnd_methods/onchain/request_chain_fee_increase.js

@@ -54,7 +54,7 @@ module.exports = (args, cbk) => {
       feeRate: ['validate', ({}, cbk) => {
         // Exit early when the fee rate is specified
         if (!!args.fee_tokens_per_vbyte) {
-          return cbk(null, {sat_per_byte: args.fee_tokens_per_vbyte});
+          return cbk(null, {sat_per_vbyte: args.fee_tokens_per_vbyte});
         }
 
         // Exit early when the confirmation target is specified
@@ -69,11 +69,12 @@ module.exports = (args, cbk) => {
       request: ['feeRate', ({feeRate}, cbk) => {
         return args.lnd[type][method]({
           force: true,
+          immediate: true,
           outpoint: {
             output_index: args.transaction_vout,
             txid_str: args.transaction_id,
           },
-          sat_per_byte: feeRate.sat_per_byte,
+          sat_per_vbyte: feeRate.sat_per_vbyte,
           target_conf: feeRate.target_conf,
         },
         (err, res) => {

package/lnd_methods/onchain/send_to_chain_address.js

@@ -3,6 +3,7 @@ const {returnResult} = require('asyncjs-util');
 
 const {isLnd} = require('./../../lnd_requests');
 
+const defaultConfTarget = 6;
 const initialConfirmationCount = 0;
 const {isArray} = Array;
 const {isInteger} = Number;
@@ -83,18 +84,28 @@ module.exports = (args, cbk) => {
         return cbk();
       },
 
+      // Determine what the confirmations to confirm should be
+      targetConf: ['validate', ({}, cbk) => {
+        // Exit early when there is a chain fee rate specified
+        if (!!args.fee_tokens_per_vbyte) {
+          return cbk();
+        }
+
+        return cbk(null, args.target_confirmations || defaultConfTarget);
+      }],
+
       // Send coins
-      send: ['validate', ({}, cbk) => {
+      send: ['targetConf', ({targetConf}, cbk) => {
         return args.lnd.default.sendCoins({
           addr: args.address,
           amount: args.tokens || undefined,
           coin_selection_strategy: strategy(args.utxo_selection),
           min_confs: args.utxo_confirmations || undefined,
           label: args.description || undefined,
-          sat_per_byte: args.fee_tokens_per_vbyte || undefined,
+          sat_per_vbyte: args.fee_tokens_per_vbyte || undefined,
           send_all: args.is_send_all || undefined,
           spend_unconfirmed: args.utxo_confirmations === unconfirmedConfCount,
-          target_conf: args.target_confirmations || undefined,
+          target_conf: targetConf,
         },
         (err, res) => {
           if (!!err && err.details === lowBalanceErr) {

package/lnd_methods/onchain/send_to_chain_addresses.js

@@ -3,6 +3,7 @@ const {returnResult} = require('asyncjs-util');
 
 const {isLnd} = require('./../../lnd_requests');
 
+const defaultConfTarget = 6;
 const initialConfirmationCount = 0;
 const {isArray} = Array;
 const method = 'sendMany';
@@ -74,7 +75,17 @@ module.exports = (args, cbk) => {
         return cbk();
       },
 
-      send: ['validate', ({}, cbk) => {
+      // Determine what the confirmations to confirm should be
+      targetConf: ['validate', ({}, cbk) => {
+        // Exit early when there is a chain fee rate specified
+        if (!!args.fee_tokens_per_vbyte) {
+          return cbk();
+        }
+
+        return cbk(null, args.target_confirmations || defaultConfTarget);
+      }],
+
+      send: ['targetConf', ({targetConf}, cbk) => {
         const AddrToAmount = {};
 
         args.send_to
@@ -85,9 +96,9 @@ module.exports = (args, cbk) => {
           coin_selection_strategy: strategy(args.utxo_selection),
           label: args.description || undefined,
           min_confs: args.utxo_confirmations || undefined,
-          sat_per_byte: args.fee_tokens_per_vbyte || undefined,
+          sat_per_vbyte: args.fee_tokens_per_vbyte || undefined,
           spend_unconfirmed: args.utxo_confirmations === unconfirmedConfCount,
-          target_conf: args.target_confirmations || undefined,
+          target_conf: targetConf,
         };
 
         return args.lnd.default.sendMany(send, (err, res) => {

package/lnd_responses/index.js

@@ -38,6 +38,7 @@ const rpcPeerMessageAsMessage = require('./rpc_peer_message_as_message');
 const rpcRequestUpdateAsEvent = require('./rpc_request_update_as_event');
 const rpcResolutionAsResolution = require('./rpc_resolution_as_resolution');
 const rpcRouteAsRoute = require('./rpc_route_as_route');
+const rpcSweepAsSweep = require('./rpc_sweep_as_sweep');
 const rpcTxAsTransaction = require('./rpc_tx_as_transaction');
 const rpcUtxoAsUtxo = require('./rpc_utxo_as_utxo');
 const rpcWalletStateAsState = require('./rpc_wallet_state_as_state');
@@ -83,6 +84,7 @@ module.exports = {
   rpcRequestUpdateAsEvent,
   rpcResolutionAsResolution,
   rpcRouteAsRoute,
+  rpcSweepAsSweep,
   rpcTxAsTransaction,
   rpcUtxoAsUtxo,
   rpcWalletStateAsState,

package/lnd_responses/rpc_sweep_as_sweep.js

@@ -0,0 +1,96 @@
+const isBoolean = n => n === false || n === true;
+const isHash = n => !!n && /^[0-9A-F]{64}$/i.test(n);
+const isNumber = n => !isNaN(n);
+
+/** Convert an RPC sweep into a sweep
+
+  {
+    amount_sat: <Outpoint Value Tokens Number>
+    broadcast_attempts: <Count of Past Sweep Broadcasts Number>
+    budget: <Maximum Fee Tokens to Spend On Sweeping String>
+    deadline_height: <Maximum Confirmation Height Number>
+    immediate: <Sweep Was Specified To Skip Waiting For Batching Bool>
+    outpoint: {
+      output_index: <Transaction Output Index Number>
+      txid_str: <Transaction Id Hex String>
+    }
+    requested_sat_per_vbyte: <Requested Chain Fee Rate Tokens Per VByte String>
+    sat_per_vbyte: <Current Sweeping Chain Fee Rate Tokens Per VByte String>
+    witness_type: <Witness Type String>
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    broadcasts_count: <Total Sweep Broadcast Attempts Count Number>
+    [current_fee_rate]: <Current Chain Fee Rate Tokens Per VByte Number>
+    [initial_fee_rate]: <Requested Chain Fee Rate Tokens per VByte Number>
+    is_batching: <Requested Waiting For Batching Bool>
+    [max_fee]: <Maximum Total Fee Tokens Allowed Number>
+    [max_height]: <Targeted Maximum Confirmation Height Number>
+    tokens: <Sweep Outpoint Tokens Value Number>
+    transaction_id: <Sweeping Outpoint Transaction Id Hex String>
+    transaction_vout: <Sweeping Outpoint Transaction Output Index Number>
+    type: <Outpoint Constraint Script Type String>
+  }
+*/
+module.exports = args => {
+  if (!args) {
+    throw new Error('ExpectedSweepDetailsToDerivePendingSweep');
+  }
+
+  if (args.amount_sat === undefined) {
+    throw new Error('ExpectedSweepOutpointValueAmountInPendingSweep');
+  }
+
+  if (!isNumber(args.broadcast_attempts)) {
+    throw new Error('ExpectedBroadcastAttemptsForSweepInPendingSweep');
+  }
+
+  if (!args.budget) {
+    throw new Error('ExpectedSweepBudgetAmountForSweepInPendingSweeps');
+  }
+
+  if (!isNumber(args.deadline_height)) {
+    throw new Error('ExpectedSweepConfirmationDeadlineHeightInPendingSweep');
+  }
+
+  if (!isBoolean(args.immediate)) {
+    throw new Error('ExpectedImmediateStatusOfSweepInPendingSweeps');
+  }
+
+  if (!args.outpoint) {
+    throw new Error('ExpectedUnspentOutpointOfSweepInPendingSweeps');
+  }
+
+  if (!isNumber(args.outpoint.output_index)) {
+    throw new Error('ExpectedOutputIndexOfSweepInPendingSweeps');
+  }
+
+  if (!isHash(args.outpoint.txid_str)) {
+    throw new Error('ExpectedOutpointTransactionIdHexStringInSweep');
+  }
+
+  if (!args.requested_sat_per_vbyte) {
+    throw new Error('ExpectedRequestedSatPerVByteForSweepInPendingSweeps');
+  }
+
+  if (!args.sat_per_vbyte) {
+    throw new Error('ExpectedSatPerVByteForSweepInPendingSweeps');
+  }
+
+  return {
+    broadcasts_count: args.broadcast_attempts,
+    current_fee_rate: Number(args.sat_per_vbyte) || undefined,
+    initial_fee_rate: Number(args.requested_sat_per_vbyte) || undefined,
+    is_batching: !args.immediate,
+    max_fee: Number(args.budget) || undefined,
+    max_height: args.deadline_height || undefined,
+    tokens: args.amount_sat,
+    transaction_id: args.outpoint.txid_str,
+    transaction_vout: args.outpoint.output_index,
+    type: args.witness_type.toLowerCase(),
+  };
+};

package/package.json

@@ -7,9 +7,9 @@
     "url": "https://github.com/alexbosworth/lightning/issues"
   },
   "dependencies": {
-    "@grpc/grpc-js": "1.10.6",
-    "@grpc/proto-loader": "0.7.12",
-    "@types/node": "20.12.7",
+    "@grpc/grpc-js": "1.10.7",
+    "@grpc/proto-loader": "0.7.13",
+    "@types/node": "20.12.8",
     "@types/request": "2.48.12",
     "@types/ws": "8.5.10",
     "async": "3.2.5",
@@ -17,12 +17,12 @@
     "bitcoinjs-lib": "6.1.5",
     "bn.js": "5.2.1",
     "bolt07": "1.8.4",
-    "bolt09": "2.0.0",
+    "bolt09": "2.1.0",
     "ecpair": "2.1.0",
     "invoices": "3.0.0",
     "psbt": "3.0.0",
     "tiny-secp256k1": "2.2.3",
-    "type-fest": "4.17.0"
+    "type-fest": "4.18.1"
   },
   "description": "Lightning Network client library",
   "devDependencies": {
@@ -53,5 +53,5 @@
     "directory": "test/typescript"
   },
   "types": "index.d.ts",
-  "version": "10.9.2"
+  "version": "10.10.1"
 }

package/test/lnd_messages/test_close_channel_request.js

@@ -12,7 +12,7 @@ const makeArgs = overrides => {
     },
     delivery_address: 'delivery_address',
     force: true,
-    sat_per_byte: '1',
+    sat_per_vbyte: '1',
     target_conf: 1,
   };
 
@@ -47,7 +47,7 @@ const tests = [
     args: makeArgs({
       delivery_address: '',
       force: false,
-      sat_per_byte: '0',
+      sat_per_vbyte: '0',
       target_conf: 0,
     }),
     description: 'Defaults are selected',

package/test/lnd_methods/macaroon/test_handle_rpc_request_update.js

@@ -19,7 +19,7 @@ const tests = [
               },
               delivery_address: 'delivery_address',
               force: true,
-              sat_per_byte: '1',
+              sat_per_vbyte: '1',
               target_conf: 1,
             }),
           },

package/test/lnd_methods/offchain/test_get_connected_watchtowers.js

@@ -28,7 +28,7 @@ const makeTower = overrides => {
       max_backups: 1,
       num_backups: 1,
       num_pending_backups: 1,
-      sweep_sat_per_byte: 1,
+      sweep_sat_per_vbyte: 1,
     }],
   };
 
@@ -60,7 +60,7 @@ const makeLnd = args => {
           return cbk(null, args.policyRes);
         }
 
-        return cbk(null, {max_updates: 1, sweep_sat_per_byte: 1});
+        return cbk(null, {max_updates: 1, sweep_sat_per_vbyte: 1});
       },
       stats: ({}, cbk) => {
         if (!!args.statsErr) {

package/test/lnd_methods/onchain/test_get_chain_fee_estimate.js

@@ -57,52 +57,12 @@ const tests = [
     description: 'Fee sat is expected in estimate fee response',
     error: [503, 'ExpectedChainFeeInResponseToChainFeeEstimate'],
   },
-  {
-    args: {
-      lnd: {default: {estimateFee: ({}, cbk) => cbk(null, {fee_sat: '1'})}},
-      send_to: [{address: 'address', tokens: 1}],
-    },
-    description: 'Fee rate is expected in estimate fee response',
-    error: [503, 'ExpectedFeeRateValueInChainFeeEstimateQuery'],
-  },
-  {
-    args: {
-      lnd: {
-        default: {
-          estimateFee: ({}, cbk) => cbk(null, {
-            fee_sat: '1',
-            feerate_sat_per_byte: '1',
-          }),
-        },
-      },
-      send_to: [{address: 'address', tokens: 1}],
-    },
-    description: 'Fee rate and fee are given in chain response',
-    expected: {fee: 1, tokens_per_vbyte: 1},
-  },
-  {
-    args: {
-      lnd: {
-        default: {
-          estimateFee: ({}, cbk) => cbk(null, {
-            fee_sat: '1',
-            feerate_sat_per_byte: '1',
-          }),
-        },
-      },
-      send_to: [{address: 'address', tokens: 1}],
-      utxo_confirmations: 0,
-    },
-    description: 'Passing 0 UTXO confirmations is supported',
-    expected: {fee: 1, tokens_per_vbyte: 1},
-  },
   {
     args: {
       lnd: {
         default: {
           estimateFee: ({}, cbk) => cbk(null, {
             fee_sat: '1',
-            feerate_sat_per_byte: '1',
             sat_per_vbyte: '2',
           }),
         },
@@ -119,7 +79,6 @@ const tests = [
         default: {
           estimateFee: ({}, cbk) => cbk(null, {
             fee_sat: '1',
-            feerate_sat_per_byte: '1',
             sat_per_vbyte: '2',
           }),
         },

package/test/lnd_methods/onchain/test_get_pending_sweeps.js

@@ -0,0 +1,92 @@
+const {strictEqual} = require('node:assert').strict;
+const {rejects} = require('node:assert').strict;
+const test = require('node:test');
+
+const {getPendingSweeps} = require('./../../../lnd_methods');
+
+const tests = [
+  {
+    args: {},
+    description: 'LND Object is required to get pending sweeps',
+    error: [400, 'ExpectedLndToGetPendingSweeps'],
+  },
+  {
+    args: {lnd: {wallet: {pendingSweeps: ({}, cbk) => cbk('err')}}},
+    description: 'Errors are passed back from method',
+    error: [503, 'UnexpectedGetPendingSweepsError', {err: 'err'}],
+  },
+  {
+    args: {lnd: {wallet: {pendingSweeps: ({}, cbk) => cbk()}}},
+    description: 'A result is expected from the method',
+    error: [503, 'ExpectedResponseToGetPendingSweepsRequest'],
+  },
+  {
+    args: {lnd: {wallet: {pendingSweeps: ({}, cbk) => cbk(null, {})}}},
+    description: 'An array of sweeps is expected in response',
+    error: [503, 'ExpectedArrayOfPendingSweepsInSweepsResponse'],
+  },
+  {
+    args: {
+      lnd: {
+        wallet: {
+          pendingSweeps: ({}, cbk) => cbk(null, {pending_sweeps: [null]}),
+        },
+      },
+    },
+    description: 'An array of sweeps is expected in response',
+    error: [503, 'ExpectedSweepDetailsToDerivePendingSweep'],
+  },
+  {
+    args: {
+      lnd: {
+        wallet: {
+          pendingSweeps: ({}, cbk) => cbk(null, {
+            pending_sweeps: [{
+              amount_sat: 0,
+              broadcast_attempts: 0,
+              budget: '0',
+              deadline_height: 0,
+              immediate: true,
+              outpoint: {
+                output_index: 0,
+                txid_str: Buffer.alloc(32).toString('hex'),
+              },
+              requested_sat_per_vbyte: '0',
+              sat_per_vbyte: '0',
+              witness_type: 'witness_type',
+            }],
+          }),
+        },
+      },
+    },
+    description: 'Pending sweeps are returned',
+    expected: {
+      sweeps: [{
+        broadcasts_count: 0,
+        current_fee_rate: undefined,
+        initial_fee_rate: undefined,
+        is_batching: false,
+        max_fee: undefined,
+        max_height: undefined,
+        tokens: 0,
+        transaction_id: Buffer.alloc(32).toString('hex'),
+        transaction_vout: 0,
+        type: 'witness_type',
+      }],
+    },
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, async () => {
+    if (!!error) {
+      await rejects(() => getPendingSweeps(args), error, 'Got expected error');
+    } else {
+      const res = await getPendingSweeps(args);
+
+      strictEqual(res.chain_balance, expected.chain_balance, 'Got balance');
+    }
+
+    return;
+  });
+});

package/test/lnd_methods/onchain/test_request_batched_fee_increase.js

@@ -0,0 +1,111 @@
+const EventEmitter = require('events');
+const {rejects} = require('node:assert').strict;
+const test = require('node:test');
+
+const {requestBatchedFeeIncrease} = require('./../../../lnd_methods');
+
+const makeLnd = overrides => {
+  const res = {status: 'status'};
+
+  Object.keys(overrides).forEach(k => res[k] = overrides[k]);
+
+  return {
+    chain: {
+      registerBlockEpochNtfn: ({}) => {
+        const emitter = new EventEmitter();
+
+        emitter.cancel = () => {};
+
+        process.nextTick(() => emitter.emit('data', {
+          hash: Buffer.alloc(32),
+          height: 500,
+        }));
+
+        return emitter;
+      },
+    },
+    wallet: {bumpFee: (args, cbk) => cbk(null, res)},
+  };
+};
+
+const makeArgs = overrides => {
+  const args = {
+    lnd: makeLnd({}),
+    transaction_id: Buffer.alloc(32).toString('hex'),
+    transaction_vout: 0,
+  };
+
+  Object.keys(overrides).forEach(key => args[key] = overrides[key]);
+
+  return args;
+};
+
+const tests = [
+  {
+    args: makeArgs({lnd: undefined}),
+    description: 'An LND object is required',
+    error: [400, 'ExpectedLndToRequestChainFeeIncrease'],
+  },
+  {
+    args: makeArgs({transaction_id: undefined}),
+    description: 'A transaction id is required',
+    error: [400, 'ExpectedTransactionIdToRequestChainFeeIncrease'],
+  },
+  {
+    args: makeArgs({transaction_vout: undefined}),
+    description: 'A tx output index is required',
+    error: [400, 'ExpectedTransactionOutputIndexToRequestFeeBump'],
+  },
+  {
+    args: makeArgs({
+      lnd: {
+        wallet: {
+          bumpFee: ({}, cbk) => cbk({
+            details: 'the passed output does not belong to the wallet',
+          }),
+        },
+      },
+    }),
+    description: 'Unknown UTXO error is passed back',
+    error: [404, 'SpecifiedUtxoNotFoundInWalletUtxos'],
+  },
+  {
+    args: makeArgs({lnd: {wallet: {bumpFee: ({}, cbk) => cbk('err')}}}),
+    description: 'Errors are passed back',
+    error: [503, 'UnexpectedErrorRequestingBatchIncrease', {err: 'err'}],
+  },
+  {
+    args: makeArgs({lnd: {wallet: {bumpFee: ({}, cbk) => cbk()}}}),
+    description: 'A response is expected',
+    error: [503, 'ExpectedResponseToBatchedFeeIncreaseRequest'],
+  },
+  {
+    args: makeArgs({lnd: {wallet: {bumpFee: ({}, cbk) => cbk(null, {})}}}),
+    description: 'A response status is expected',
+    error: [503, 'ExpectedStatusOfBatchedFeeIncrease'],
+  },
+  {
+    args: makeArgs({}),
+    description: 'Fee bump is requested',
+  },
+  {
+    args: makeArgs({max_height: 1000}),
+    description: 'Fee bump is requested with a height',
+  },
+  {
+    args: makeArgs({max_height: 2}),
+    description: 'Fee bump is requested with a low height',
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, async () => {
+    if (!!error) {
+      await rejects(requestBatchedFeeIncrease(args), error, 'Got error');
+    } else {
+      await requestBatchedFeeIncrease(args);
+    }
+
+    return;
+  });
+});