lightning 5.3.4 → 5.5.0

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Versions
 
+## 5.5.0
+
+- `partiallySignPsbt`: Add method to partially sign a PSBT
+
+## 5.4.2
+
+- `deletePendingChannel`: Add method to delete a stuck pending channel
+- `getInvoices`: Fill in type definition for `is_unconfirmed`
+
 ## 5.3.4
 
 - `getPayments`: Correct paging issue that prevented paging through all results

package/README.md

@@ -206,8 +206,10 @@ To access unauthenticated methods like the wallet unlocker, use
     chosen to be spent.
 - [openChannel](https://github.com/alexbosworth/ln-service#openchannel): Create a new channel
     to another node.
-- [openChannels](https://github.com/alexbosworth/ln-service#openchannels): Open multiple
-    channels in a single on-chain transaction batch.
+- [openChannels](https://github.com/alexbosworth/ln-service#openchannels): Open
+     multiple channels in a single on-chain transaction batch.
+- [partiallySignPsbt](https://github.com/alexbosworth/ln-service#partiallysignpsbt):
+    Add a partial signature to a PSBT
 - [pay](https://github.com/alexbosworth/ln-service#pay): Make an off-chain payment.
 - [payViaPaymentDetails](https://github.com/alexbosworth/ln-service#payviapaymentdetails): Pay
     off-chain using details about a destination invoice.

package/grpc/protos/lightning.proto

@@ -1210,13 +1210,13 @@ enum CommitmentType {
     /*
     Returned when the commitment type isn't known or unavailable.
     */
-    UNKNOWN_COMMITMENT_TYPE = 999;
+    UNKNOWN_COMMITMENT_TYPE = 0;
 
     /*
     A channel using the legacy commitment format having tweaked to_remote
     keys.
     */
-    LEGACY = 0;
+    LEGACY = 1;
 
     /*
     A channel that uses the modern commitment format where the key in the
@@ -1224,14 +1224,14 @@ enum CommitmentType {
     up and recovery easier as when the channel is closed, the funds go
     directly to that key.
     */
-    STATIC_REMOTE_KEY = 1;
+    STATIC_REMOTE_KEY = 2;
 
     /*
     A channel that uses a commitment format that has anchor outputs on the
     commitments, allowing fee bumping after a force close transaction has
     been broadcast.
     */
-    ANCHORS = 2;
+    ANCHORS = 3;
 
     /*
     A channel that uses a commitment type that builds upon the anchors
@@ -2312,6 +2312,12 @@ message PendingChannelsResponse {
 
         // Total number of forwarding packages created in this channel.
         int64 num_forwarding_packages = 10;
+
+        // A set of flags showing the current state of the channel.
+        string chan_status_flags = 11;
+
+        // Whether this channel is advertised to the network or not.
+        bool private = 12;
     }
 
     message PendingOpenChannel {
@@ -2353,6 +2359,9 @@ message PendingChannelsResponse {
         this point.
         */
         Commitments commitments = 3;
+
+        // The transaction id of the closing transaction
+        string closing_txid = 4;
     }
 
     message Commitments {
@@ -3742,6 +3751,9 @@ message PolicyUpdateRequest {
     // goes up to 6 decimal places, so 1e-6.
     double fee_rate = 4;
 
+    // The effective fee rate in micro-satoshis (parts per million).
+    uint32 fee_rate_ppm = 9;
+
     // The required timelock delta for HTLCs forwarded over the channel.
     uint32 time_lock_delta = 5;
 

package/grpc/protos/router.proto

@@ -360,6 +360,11 @@ message QueryMissionControlResponse {
 message XImportMissionControlRequest {
     // Node pair-level mission control state to be imported.
     repeated PairHistory pairs = 1;
+
+    // Whether to force override MC pair history. Note that even with force
+    // override the failure pair is imported before the success pair and both
+    // still clamp existing failure/success amounts.
+    bool force = 2;
 }
 
 message XImportMissionControlResponse {

package/grpc/protos/walletkit.proto

@@ -200,6 +200,21 @@ service WalletKit {
     */
     rpc FundPsbt (FundPsbtRequest) returns (FundPsbtResponse);
 
+    /*
+    SignPsbt expects a partial transaction with all inputs and outputs fully
+    declared and tries to sign all unsigned inputs that have all required fields
+    (UTXO information, BIP32 derivation information, witness or sig scripts)
+    set.
+    If no error is returned, the PSBT is ready to be given to the next signer or
+    to be finalized if lnd was the last signer.
+
+    NOTE: This RPC only signs inputs (and only those it can sign), it does not
+    perform any other tasks (such as coin selection, UTXO locking or
+    input/output/fee value validation, PSBT finalization). Any input that is
+    incomplete will be skipped.
+    */
+    rpc SignPsbt (SignPsbtRequest) returns (SignPsbtResponse);
+
     /*
     FinalizePsbt expects a partial transaction with all inputs and outputs fully
     declared and tries to sign all inputs that belong to the wallet. Lnd must be
@@ -820,6 +835,19 @@ message UtxoLease {
     uint64 expiration = 3;
 }
 
+message SignPsbtRequest {
+    /*
+    The PSBT that should be signed. The PSBT must contain all required inputs,
+    outputs, UTXO data and custom fields required to identify the signing key.
+    */
+    bytes funded_psbt = 1;
+}
+
+message SignPsbtResponse {
+    // The signed transaction in PSBT format.
+    bytes signed_psbt = 1;
+}
+
 message FinalizePsbtRequest {
     /*
     A PSBT that should be signed and finalized. The PSBT must contain all

package/index.js

@@ -76,6 +76,7 @@ const {lndGateway} = require('./lnd_gateway');
 const {lockUtxo} = require('./lnd_methods');
 const {openChannel} = require('./lnd_methods');
 const {openChannels} = require('./lnd_methods');
+const {partiallySignPsbt} = require('./lnd_methods');
 const {pay} = require('./lnd_methods');
 const {payViaPaymentDetails} = require('./lnd_methods');
 const {payViaPaymentRequest} = require('./lnd_methods');
@@ -213,6 +214,7 @@ module.exports = {
   lockUtxo,
   openChannel,
   openChannels,
+  partiallySignPsbt,
   pay,
   payViaPaymentDetails,
   payViaPaymentRequest,

package/lnd_methods/index.js

@@ -72,6 +72,7 @@ const {isDestinationPayable} = require('./offchain');
 const {lockUtxo} = require('./onchain');
 const {openChannel} = require('./onchain');
 const {openChannels} = require('./onchain');
+const {partiallySignPsbt} = require('./onchain');
 const {pay} = require('./offchain');
 const {payViaPaymentDetails} = require('./offchain');
 const {payViaPaymentRequest} = require('./offchain');
@@ -205,6 +206,7 @@ module.exports = {
   lockUtxo,
   openChannel,
   openChannels,
+  partiallySignPsbt,
   pay,
   payViaPaymentDetails,
   payViaPaymentRequest,

package/lnd_methods/invoices/get_invoices.d.ts

@@ -4,7 +4,12 @@ import {
   PaginationArgs,
 } from '../../typescript';
 
-export type GetInvoicesArgs = AuthenticatedLightningArgs<PaginationArgs>;
+export type GetInvoicesArgs = AuthenticatedLightningArgs<
+  PaginationArgs & {
+    /** Omit Canceled and Settled Invoices Bool */
+    is_unconfirmed?: boolean;
+  }
+>;
 
 export type GetInvoicesResult = {
   invoices: {

package/lnd_methods/macaroon/methods.json

@@ -293,6 +293,10 @@
     "method": "OpenChannel",
     "type": "default"
   },
+  "partiallySignPsbt": {
+    "method": "SignPsbt",
+    "type": "wallet"
+  },
   "payViaPaymentDetails": {
     "depends_on": ["subscribeToPayViaDetails"]
   },

package/lnd_methods/offchain/delete_pending_channel.d.ts

@@ -0,0 +1,21 @@
+import {
+  AuthenticatedLightningArgs,
+  AuthenticatedLightningMethod,
+} from '../../typescript';
+
+export type DeletePendingChannelArgs = AuthenticatedLightningArgs<{
+  /** Hex Encoded Conflicting Transaction String */
+  confirmed_transaction: string;
+  /** Hex Encoded Pending Transaction String */
+  pending_transaction: string;
+  /** Pending Channel Output Index Number */
+  pending_transaction_vout: number;
+}>;
+
+/**
+ * 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
+ */
+export const deletePendingChannel: AuthenticatedLightningMethod<DeletePendingChannelArgs>;

package/lnd_methods/offchain/delete_pending_channel.js

@@ -4,6 +4,7 @@ const {Transaction} = require('bitcoinjs-lib');
 
 const {fromHex} = Transaction;
 const method = 'abandonChannel';
+const methodUnsupported = 'AbandonChannel RPC call only available in dev builds';
 const txIdAsHash = id => Buffer.from(id, 'hex').reverse();
 const type = 'default';
 
@@ -96,6 +97,10 @@ module.exports = (args, cbk) => {
           i_know_what_i_am_doing: true,
         },
         err => {
+          if (!!err && err.details === methodUnsupported) {
+            return cbk([501, 'DeletePendingChannelMethodNotSupported']);
+          }
+
           if (!!err) {
             return cbk([503, 'UnexpectedErrorDeletingPendingChannel', {err}]);
           }

package/lnd_methods/offchain/index.d.ts

@@ -5,6 +5,7 @@ export * from './delete_failed_payments';
 export * from './delete_forwarding_reputations';
 export * from './delete_payment';
 export * from './delete_payments';
+export * from './delete_pending_channel';
 export * from './disable_channel';
 export * from './disconnect_watchtower';
 export * from './enable_channel';

package/lnd_methods/onchain/index.d.ts

@@ -14,6 +14,7 @@ export * from './get_utxos';
 export * from './lock_utxo';
 export * from './open_channel';
 export * from './open_channels';
+export * from './partially_sign_psbt';
 export * from './prepare_for_channel_proposal';
 export * from './propose_channel';
 export * from './request_chain_fee_increase';

package/lnd_methods/onchain/index.js

@@ -14,6 +14,7 @@ const getUtxos = require('./get_utxos');
 const lockUtxo = require('./lock_utxo');
 const openChannel = require('./open_channel');
 const openChannels = require('./open_channels');
+const partiallySignPsbt = require('./partially_sign_psbt');
 const prepareForChannelProposal = require('./prepare_for_channel_proposal');
 const proposeChannel = require('./propose_channel');
 const requestChainFeeIncrease = require('./request_chain_fee_increase');
@@ -46,6 +47,7 @@ module.exports = {
   lockUtxo,
   openChannel,
   openChannels,
+  partiallySignPsbt,
   prepareForChannelProposal,
   proposeChannel,
   requestChainFeeIncrease,

package/lnd_methods/onchain/partially_sign_psbt.d.ts

@@ -0,0 +1,28 @@
+import {
+  AuthenticatedLightningArgs,
+  AuthenticatedLightningMethod,
+} from '../../typescript';
+
+export type PartiallySignPsbtArgs = AuthenticatedLightningArgs<{
+  /** Funded PSBT Hex String */
+  psbt: string;
+}>;
+
+export type PartiallySignPsbtResult = {
+  /** Partially Signed PSBT Hex String */
+  psbt: string;
+};
+
+/**
+ * Sign a PSBT to produce a partially signed PSBT
+ *
+ * Requires `onchain:write` permission
+ *
+ * Requires LND built with `walletrpc` tag
+ *
+ * This method is not supported in LND 0.14.1 and below
+ */
+export const partiallySignPsbt: AuthenticatedLightningMethod<
+  PartiallySignPsbtArgs,
+  PartiallySignPsbtResult
+>;

package/lnd_methods/onchain/partially_sign_psbt.js

@@ -0,0 +1,79 @@
+const asyncAuto = require('async/auto');
+const {returnResult} = require('asyncjs-util');
+
+const {isLnd} = require('./../../lnd_requests');
+
+const bufferAsHex = buffer => buffer.toString('hex');
+const hexAsBuf = hex => Buffer.from(hex, 'hex');
+const {isBuffer} = Buffer;
+const method = 'signPsbt';
+const notSupported = /unknown.*walletrpc.WalletKit/;
+const type = 'wallet';
+
+/** Sign a PSBT to produce a partially signed PSBT
+
+  Requires `onchain:write` permission
+
+  Requires LND built with `walletrpc` tag
+
+  This method is not supported in LND 0.14.1 and below
+
+  {
+    lnd: <Authenticated LND API Object>
+    psbt: <Funded PSBT Hex String>
+  }
+
+  @returns via cbk or Promise
+  {
+    psbt: <Partially Signed PSBT Hex String>
+  }
+*/
+module.exports = ({lnd, psbt}, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!isLnd({lnd, method, type})) {
+          return cbk([400, 'ExpectedAuthenticatedLndToPartiallySignPsbt']);
+        }
+
+        if (!psbt) {
+          return cbk([400, 'ExpectedPsbtToPartiallySign']);
+        }
+
+        return cbk();
+      },
+
+      // Partially sign the funded PSBT
+      sign: ['validate', ({}, cbk) => {
+        return lnd[type][method]({funded_psbt: hexAsBuf(psbt)}, (err, res) => {
+          if (!!err && notSupported.test(err.details)) {
+            return cbk([501, 'PartiallySignPsbtMethodNotSupported']);
+          }
+
+          if (!!err) {
+            return cbk([503, 'UnexpectedErrorPartiallySigningPsbt', {err}]);
+          }
+
+          if (!res) {
+            return cbk([503, 'ExpectedResponseWhenPartiallySigningPsbt']);
+          }
+
+          if (!isBuffer(res.signed_psbt)) {
+            return cbk([503, 'ExpectedSignPsbtInSignPsbtResult']);
+          }
+
+          const signed = bufferAsHex(res.signed_psbt);
+
+          // Detect a failure to add a partial signature
+          if (signed === psbt) {
+            return cbk([503, 'FailedToModifyInputPsbt']);
+          }
+
+          return cbk(null, {psbt: signed});
+        });
+      }],
+    },
+    returnResult({reject, resolve, of: 'sign'}, cbk));
+  });
+};

package/lnd_methods/peers/get_peers.d.ts

@@ -22,7 +22,7 @@ export type GetPeersResult = {
     /** Is Syncing Graph Data */
     is_sync_peer?: boolean;
     /** Peer Last Reconnected At ISO 8601 Date */
-    last_reconnected?: string;
+    last_reconnection?: string;
     /** Ping Latency Milliseconds */
     ping_time: number;
     /** Node Identity Public Key */

package/lnd_methods/peers/get_peers.js

@@ -31,7 +31,7 @@ const type = 'default';
       }]
       is_inbound: <Is Inbound Peer Bool>
       [is_sync_peer]: <Is Syncing Graph Data Bool>
-      [last_reconnected]: <Peer Last Reconnected At ISO 8601 Date String>
+      [last_reconnection]: <Peer Last Reconnected At ISO 8601 Date String>
       ping_time: <Ping Latency Milliseconds Number>
       public_key: <Node Identity Public Key String>
       [reconnection_rate]: <Count of Reconnections Over Time Number>

package/lnd_methods/unauthenticated/create_wallet.d.ts

@@ -12,9 +12,17 @@ export type CreateWalletArgs = UnauthenticatedLightningArgs<{
   seed: string;
 }>;
 
+export type CreateWalletResult = {
+  /** Base64 Encoded Admin Macaroon String */
+  macaroon: string;
+};
+
 /**
  * Create a wallet
  *
  * Requires unlocked lnd and unauthenticated LND
  */
-export const createWallet: UnauthenticatedLightningMethod<CreateWalletArgs>;
+export const createWallet: UnauthenticatedLightningMethod<
+  CreateWalletArgs,
+  CreateWalletResult
+>;

package/lnd_responses/rpc_peer_as_peer.js

@@ -49,7 +49,7 @@ const microPerMilli = 1e3;
     }]
     is_inbound: <Is Inbound Peer Bool>
     [is_sync_peer]: <Is Syncing Graph Data Bool>
-    [last_reconnected]: <Peer Last Reconnected At ISO 8601 Date String>
+    [last_reconnection]: <Peer Last Reconnected At ISO 8601 Date String>
     ping_time: <Milliseconds Number>
     public_key: <Public Key String>
     [reconnection_rate]: <Count of Reconnections Over Time Number>

package/package.json

@@ -10,7 +10,7 @@
     "@grpc/grpc-js": "1.5.3",
     "@grpc/proto-loader": "0.6.9",
     "@types/express": "4.17.13",
-    "@types/node": "17.0.10",
+    "@types/node": "17.0.13",
     "@types/request": "2.48.8",
     "@types/ws": "8.2.2",
     "async": "3.2.3",
@@ -23,8 +23,8 @@
     "cbor": "8.1.0",
     "express": "4.17.2",
     "invoices": "2.0.3",
-    "psbt": "1.1.10",
-    "type-fest": "2.10.0"
+    "psbt": "1.1.11",
+    "type-fest": "2.11.0"
   },
   "description": "Lightning Network client library",
   "devDependencies": {
@@ -57,5 +57,5 @@
     "directory": "test/typescript"
   },
   "types": "index.d.ts",
-  "version": "5.3.4"
+  "version": "5.5.0"
 }

package/test/lnd_methods/offchain/test_delete_pending_channel.js

@@ -67,6 +67,13 @@ const tests = [
     description: 'A conflicting tx is required',
     error: [400, 'FailedToFindConflictingInputInConfirmedTx'],
   },
+  {
+    args: makeArgs({lnd: {default: {abandonChannel: ({}, cbk) => cbk({
+      details: 'AbandonChannel RPC call only available in dev builds',
+    })}}}),
+    description: 'Method unsupported error is returned',
+    error: [501, 'DeletePendingChannelMethodNotSupported'],
+  },
   {
     args: makeArgs({lnd: {default: {abandonChannel: ({}, cbk) => cbk('er')}}}),
     description: 'A server error is passed back',

package/test/lnd_methods/onchain/test_partially_sign_psbt.js

@@ -0,0 +1,100 @@
+const {test} = require('@alexbosworth/tap');
+
+const {partiallySignPsbt} = require('./../../../lnd_methods');
+
+const unsupported = {details: 'unknown method for service walletrpc.WalletKit'};
+
+const makeLnd = overrides => {
+  const res = {signed_psbt: Buffer.alloc(2)};
+
+  Object.keys(overrides).forEach(k => res[k] = overrides[k]);
+
+  return {wallet: {signPsbt: (args, cbk) => cbk(null, res)}};
+};
+
+const makeArgs = overrides => {
+  const args = {lnd: makeLnd({}), psbt: '00'};
+
+  Object.keys(overrides).forEach(key => args[key] = overrides[key]);
+
+  return args;
+};
+
+const makeExpected = overrides => {
+  const expected = {psbt: '0000'};
+
+  Object.keys(overrides).forEach(k => expected[k] = overrides[k]);
+
+  return expected;
+};
+
+const tests = [
+  {
+    args: makeArgs({lnd: undefined}),
+    description: 'An LND object is required',
+    error: [400, 'ExpectedAuthenticatedLndToPartiallySignPsbt'],
+  },
+  {
+    args: makeArgs({psbt: undefined}),
+    description: 'A PSBT is required',
+    error: [400, 'ExpectedPsbtToPartiallySign'],
+  },
+  {
+    args: makeArgs({
+      lnd: {
+        wallet: {
+          signPsbt: ({}, cbk) => cbk({
+            details: 'unknown method for service walletrpc.WalletKit',
+          }),
+        },
+      },
+    }),
+    description: 'Unsupported error is passed back',
+    error: [501, 'SignPsbtMethodNotSupported'],
+  },
+  {
+    args: makeArgs({lnd: {wallet: {signPsbt: ({}, cbk) => cbk('err')}}}),
+    description: 'Errors signing are passed back',
+    error: [503, 'UnexpectedErrorPartiallySigningPsbt', {err: 'err'}],
+  },
+  {
+    args: makeArgs({lnd: {wallet: {signPsbt: ({}, cbk) => cbk()}}}),
+    description: 'A result is expected',
+    error: [503, 'ExpectedResponseWhenPartiallySigningPsbt'],
+  },
+  {
+    args: makeArgs({lnd: makeLnd({signed_psbt: undefined})}),
+    description: 'A partially signed psbt is expected',
+    error: [503, 'ExpectedSignPsbtInSignPsbtResult'],
+  },
+  {
+    args: makeArgs({
+      lnd: {
+        wallet: {
+          signPsbt: ({}, cbk) => cbk(null, {signed_psbt: Buffer.alloc(1)}),
+        },
+      },
+    }),
+    description: 'A signature is expected',
+    error: [503, 'FailedToModifyInputPsbt'],
+  },
+  {
+    args: makeArgs({}),
+    description: 'PSBT partial signing is executed',
+    expected: makeExpected({}),
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, async ({end, rejects, strictSame}) => {
+    if (!!error) {
+      await rejects(partiallySignPsbt(args), error, 'Got error');
+    } else {
+      const got = await partiallySignPsbt(args);
+
+      strictSame(got, expected, 'Got expected result');
+    }
+
+    return end();
+  });
+});

package/test/protos/protos.json

@@ -1,10 +1,6 @@
 {
   "overrides": [
-    ["lightning", 1212],
-    ["lightning", 1218],
-    ["lightning", 1226],
-    ["lightning", 1233],
-    ["lightning", 3459],
+    ["lightning", 3468],
     ["router", 100],
     ["walletkit", 3],
     ["walletunlocker", 2]

package/test/typescript/create_wallet.test-d.ts

@@ -1,6 +1,6 @@
 import {expectError, expectType} from 'tsd';
 import {UnauthenticatedLnd} from '../../lnd_grpc';
-import {createWallet} from '../../lnd_methods';
+import {createWallet, CreateWalletResult} from '../../lnd_methods';
 
 const lnd = {} as UnauthenticatedLnd;
 
@@ -20,8 +20,14 @@ expectError(createWallet({lnd, seed}));
 expectError(createWallet({lnd, passphrase, password}));
 expectError(createWallet({lnd, passphrase, seed}));
 
-expectType<void>(await createWallet({lnd, password, seed}));
-expectType<void>(await createWallet({lnd, passphrase, password, seed}));
+expectType<CreateWalletResult>(await createWallet({lnd, password, seed}));
+expectType<CreateWalletResult>(
+  await createWallet({lnd, passphrase, password, seed})
+);
 
-expectType<void>(createWallet({lnd, password, seed}, () => {}));
-expectType<void>(createWallet({lnd, passphrase, password, seed}, () => {}));
+createWallet({lnd, password, seed}, (err, res) => {
+  expectType<CreateWalletResult>(res);
+});
+createWallet({lnd, passphrase, password, seed}, (err, res) => {
+  expectType<CreateWalletResult>(res);
+});

package/test/typescript/delete_pending_channel.test-d.ts

@@ -0,0 +1,43 @@
+import {expectError, expectType} from 'tsd';
+import {AuthenticatedLnd} from '../../lnd_grpc';
+import {deletePendingChannel} from '../../lnd_methods';
+
+const lnd = {} as AuthenticatedLnd;
+const confirmed_transaction = 'tx0';
+const pending_transaction = 'tx1';
+const pending_transaction_vout = 1;
+
+expectError(deletePendingChannel());
+expectError(deletePendingChannel({}));
+expectError(deletePendingChannel({lnd}));
+expectError(deletePendingChannel({confirmed_transaction}));
+expectError(deletePendingChannel({pending_transaction}));
+expectError(deletePendingChannel({pending_transaction_vout}));
+expectError(deletePendingChannel({lnd, confirmed_transaction}));
+expectError(deletePendingChannel({lnd, pending_transaction}));
+expectError(deletePendingChannel({lnd, pending_transaction_vout}));
+expectError(
+  deletePendingChannel({lnd, confirmed_transaction, pending_transaction})
+);
+expectError(
+  deletePendingChannel({lnd, confirmed_transaction, pending_transaction_vout})
+);
+expectError(
+  deletePendingChannel({lnd, pending_transaction, pending_transaction_vout})
+);
+
+expectType<void>(
+  await deletePendingChannel({
+    lnd,
+    confirmed_transaction,
+    pending_transaction,
+    pending_transaction_vout,
+  })
+);
+
+expectType<void>(
+  deletePendingChannel(
+    {lnd, confirmed_transaction, pending_transaction, pending_transaction_vout},
+    () => {}
+  )
+);

package/test/typescript/get_invoices.test-d.ts

@@ -5,14 +5,18 @@ import {getInvoices, GetInvoicesResult} from '../../lnd_methods';
 const lnd = {} as AuthenticatedLnd;
 const limit = 100;
 const token = 'token';
+const is_unconfirmed = true;
 
 expectError(getInvoices());
 expectError(getInvoices({}));
 expectError(getInvoices({lnd, limit, token}));
+expectError(getInvoices({lnd, limit, token, is_unconfirmed}));
 
 expectType<GetInvoicesResult>(await getInvoices({lnd}));
 expectType<GetInvoicesResult>(await getInvoices({lnd, limit}));
+expectType<GetInvoicesResult>(await getInvoices({lnd, limit, is_unconfirmed}));
 expectType<GetInvoicesResult>(await getInvoices({lnd, token}));
+expectType<GetInvoicesResult>(await getInvoices({lnd, token, is_unconfirmed}));
 
 expectType<void>(
   getInvoices({lnd}, (error, result) => {
@@ -24,8 +28,18 @@ expectType<void>(
     expectType<GetInvoicesResult>(result);
   })
 );
+expectType<void>(
+  getInvoices({lnd, limit, is_unconfirmed}, (error, result) => {
+    expectType<GetInvoicesResult>(result);
+  })
+);
 expectType<void>(
   getInvoices({lnd, token}, (error, result) => {
     expectType<GetInvoicesResult>(result);
   })
 );
+expectType<void>(
+  getInvoices({lnd, token, is_unconfirmed}, (error, result) => {
+    expectType<GetInvoicesResult>(result);
+  })
+);

package/test/typescript/partially_sign_psbt.test-d.ts

@@ -0,0 +1,18 @@
+import {expectError, expectType} from 'tsd';
+import {AuthenticatedLnd} from '../../lnd_grpc';
+import {partiallySignPsbt, PartiallySignPsbtResult} from '../../lnd_methods';
+
+const lnd = {} as AuthenticatedLnd;
+const psbt = 'psbt';
+
+expectError(partiallySignPsbt());
+expectError(partiallySignPsbt({}));
+expectError(partiallySignPsbt({lnd}));
+
+expectType<PartiallySignPsbtResult>(await partiallySignPsbt({lnd, psbt}));
+
+expectType<void>(
+  partiallySignPsbt({lnd, psbt}, (error, result) => {
+    expectType<PartiallySignPsbtResult>(result);
+  })
+);