lightning 5.15.1 → 5.16.1

package/CHANGELOG.md

@@ -1,6 +1,10 @@
 # Versions
 
-## 5.15.1
+## 5.16.1
+
+- `signTransaction`: Add `root_hash` to support Taproot signatures with scripts
+
+## 5.15.2
 
 - `getFailedPayments`, `getPayments`, `getPendingPayments`: Remove
     `confirmed_at` date when a payment is not confirmed, add `created_at` and

package/README.md

@@ -66,9 +66,13 @@ To access unauthenticated methods like the wallet unlocker, use
 
 ## Methods
 
+- [addExternalSocket](https://github.com/alexbosworth/ln-service#addexternalsocket):
+    Add a new LN p2p network socket to node advertisement
 - [addPeer](https://github.com/alexbosworth/ln-service#addpeer): Connect to a new peer
 - [authenticatedLndGrpc](https://github.com/alexbosworth/ln-service#authenticatedlndgrpc): 
     Instantiate connection to authenticated lnd methods.
+- [beginGroupSigningSession](https://github.com/alexbosworth/ln-service#begingroupsigningsession):
+    Start a new MuSig2 signing session
 - [broadcastChainTransaction](https://github.com/alexbosworth/ln-service#broadcastchaintransaction):
     Publish an on-chain transaction to the network.
 - [cancelHodlInvoice](https://github.com/alexbosworth/ln-service#cancelhodlinvoice): Cancel an
@@ -111,6 +115,8 @@ To access unauthenticated methods like the wallet unlocker, use
     Remove a connected watchtower
 - [enableChannel](https://github.com/alexbosworth/ln-service#enablechannel): Signal forwarding
     enabled towards a peer.
+- [endGroupSigningSession](https://github.com/alexbosworth/ln-service#endgroupsigningsession):
+    End a MuSig2 signing session
 - [fundPendingChannels](https://github.com/alexbosworth/ln-service#fundpendingchannels):
     Provide a signed funding source for opening channels.
 - [fundPsbt](https://github.com/alexbosworth/ln-service#fundpsbt): Make a PSBT with funds and
@@ -235,6 +241,8 @@ To access unauthenticated methods like the wallet unlocker, use
     Attempt to recover channel funds from a specific channel backup.
 - [recoverFundsFromChannels](https://github.com/alexbosworth/ln-service#recoverfundsfromchannels):
     Attempt to recover funds from multiple channels using a multiple channel backup.
+- [removeExternalSocket](https://github.com/alexbosworth/ln-service#removeexternalsocket):
+    Remove a LN p2p network socket from the node advertisement
 - [removePeer](https://github.com/alexbosworth/ln-service#removepeer): Disconnect from a
     connected peer.
 - [requestChainFeeIncrease](https://github.com/alexbosworth/ln-service#requestchainfeeincrease):
@@ -313,10 +321,16 @@ To access unauthenticated methods like the wallet unlocker, use
     UTXO to allow it to be selected for spending again.
 - [unlockWallet](https://github.com/alexbosworth/ln-service#unlockwallet): Decrypt the wallet and
     start the daemon
+- [updateAlias](https://github.com/alexbosworth/ln-service#updatealias):
+    Update the advertised node alias
 - [updateChainTransaction](https://github.com/alexbosworth/ln-service#updatechaintransaction):
     Edit the metadata of an on-chain transaction record.
+- [updateColor](https://github.com/alexbosworth/ln-service#updatecolor):
+    Update the advertised node color
 - [updateConnectedWatchtower](https://github.com/alexbosworth/ln-service#updateconnectedwatchtower):
     Edit the settings on an added watchtower
+- [updateGroupSigningSession](https://github.com/alexbosworth/ln-service#updategroupsigningsession):
+    Update a MuSig2 signing session with nonces and get a partial signature
 - [updatePathfindingSettings](https://github.com/alexbosworth/ln-service#updatepathfindingsettings):
     Edit the configuration for routing calculations
 - [updateRoutingFees](https://github.com/alexbosworth/ln-service#updateroutingfees): Set the

package/grpc/protos/lightning.proto

@@ -2369,9 +2369,6 @@ message PendingChannelsResponse {
         // The pending channel
         PendingChannel channel = 1;
 
-        // The height at which this channel will be confirmed
-        uint32 confirmation_height = 2;
-
         /*
         The amount calculated to be paid in fees for the current set of
         commitment transactions. The fee amount is persisted with the channel
@@ -2390,6 +2387,9 @@ message PendingChannelsResponse {
         transaction. This value can later be updated once the channel is open.
         */
         int64 fee_per_kw = 6;
+
+        // Previously used for confirmation_height. Do not reuse.
+        reserved 2;
     }
 
     message WaitingCloseChannel {
@@ -3633,6 +3633,14 @@ message ListPaymentsRequest {
     of the returned payments is always oldest first (ascending index order).
     */
     bool reversed = 4;
+
+    /*
+    If set, all payments (complete and incomplete, independent of the
+    max_payments parameter) will be counted. Note that setting this to true will
+    increase the run time of the call significantly on systems that have a lot
+    of payments, as all of them have to be iterated through to be counted.
+    */
+    bool count_total_payments = 5;
 }
 
 message ListPaymentsResponse {
@@ -3650,6 +3658,14 @@ message ListPaymentsResponse {
     as the index_offset to continue seeking forwards in the next request.
     */
     uint64 last_index_offset = 3;
+
+    /*
+    Will only be set if count_total_payments in the request was set. Represents
+    the total number of payments (complete and incomplete, independent of the
+    number of payments requested in the query) currently present in the payments
+    database.
+    */
+    uint64 total_num_payments = 4;
 }
 
 message DeletePaymentRequest {

package/grpc/protos/signer.proto

@@ -137,6 +137,7 @@ service Signer {
     MuSig2Cleanup (experimental!) allows a caller to clean up a session early in
     cases where it's obvious that the signing session won't succeed and the
     resources can be released.
+
     NOTE: The MuSig2 BIP is not final yet and therefore this API must be
     considered to be HIGHLY EXPERIMENTAL and subject to change in upcoming
     releases. Backward compatibility is not guaranteed!
@@ -174,6 +175,32 @@ message TxOut {
     bytes pk_script = 2;
 }
 
+enum SignMethod {
+    /*
+    Specifies that a SegWit v0 (p2wkh, np2wkh, p2wsh) input script should be
+    signed.
+    */
+    SIGN_METHOD_WITNESS_V0 = 0;
+
+    /*
+    Specifies that a SegWit v1 (p2tr) input should be signed by using the
+    BIP0086 method (commit to internal key only).
+    */
+    SIGN_METHOD_TAPROOT_KEY_SPEND_BIP0086 = 1;
+
+    /*
+    Specifies that a SegWit v1 (p2tr) input should be signed by using a given
+    taproot hash to commit to in addition to the internal key.
+    */
+    SIGN_METHOD_TAPROOT_KEY_SPEND = 2;
+
+    /*
+    Specifies that a SegWit v1 (p2tr) input should be spent using the script
+    path and that a specific leaf script should be signed for.
+    */
+    SIGN_METHOD_TAPROOT_SCRIPT_SPEND = 3;
+}
+
 message SignDescriptor {
     /*
     A descriptor that precisely describes *which* key to use for signing. This
@@ -208,12 +235,23 @@ message SignDescriptor {
     */
     bytes double_tweak = 3;
 
+    /*
+    The 32 byte input to the taproot tweak derivation that is used to derive
+    the output key from an internal key: outputKey = internalKey +
+    tagged_hash("tapTweak", internalKey || tapTweak).
+
+    When doing a BIP 86 spend, this field can be an empty byte slice.
+
+    When doing a normal key path spend, with the output key committing to an
+    actual script root, then this field should be: the tapscript root hash.
+    */
+    bytes tap_tweak = 10;
+
     /*
     The full script required to properly redeem the output. This field will
-    only be populated if a p2tr, p2wsh or a p2sh output is being signed. In case
-    taproot_key_spend is set to true then this value must correspond to the
-    taproot root hash (in case of a tapscript output) or the tap hashed internal
-    public key (in case of a BIP-0086 output).
+    only be populated if a p2tr, p2wsh or a p2sh output is being signed. If a
+    taproot script path spend is being attempted, then this should be the raw
+    leaf script.
     */
     bytes witness_script = 4;
 
@@ -235,12 +273,12 @@ message SignDescriptor {
     int32 input_index = 8;
 
     /*
-    Indicates that this should produce a signature that can be used for the key
-    spend path of a taproot input. This requires the witness_script field to be
-    set to the taproot root hash (in case of a tapscript output) or the tap
-    hashed internal public key (in case of a BIP-0086 output).
+    The sign method specifies how the input should be signed. Depending on the
+    method, either the tap_tweak, witness_script or both need to be specified.
+    Defaults to SegWit v0 signing to be backward compatible with older RPC
+    clients.
     */
-    bool taproot_key_spend = 9;
+    SignMethod sign_method = 9;
 }
 
 message SignReq {

package/lnd_methods/address/create_chain_address.js

@@ -6,7 +6,11 @@ const {isLnd} = require('./../../lnd_requests');
 
 const connectFailMessage = '14 UNAVAILABLE: Connect Failed';
 const defaultAddressFormat = 'p2wpkh';
+const {isArray} = Array;
+const isNeedingDerivationsCheck = format => format === 'p2tr';
+const isTrSupported = n => !!n.find(n => n.address_type === 'TAPROOT_PUBKEY');
 const method = 'newAddress';
+const notSupported = /unknown.*walletrpc.WalletKit/;
 const type = 'default';
 
 /** Create a new receive address.
@@ -42,6 +46,38 @@ module.exports = (args, cbk) => {
         return cbk();
       },
 
+      // Get account derivations to confirm P2TR support
+      checkFormat: ['validate', ({}, cbk) => {
+        // Exit early when there is no need to check the derivations
+        if (!isNeedingDerivationsCheck(args.format)) {
+          return cbk();
+        }
+
+        return args.lnd.wallet.listAccounts({}, (err, res) => {
+          if (!!err && notSupported.test(err.details)) {
+            return cbk([501, 'CreationOfTaprootAddressesUnsupported']);
+          }
+
+          if (!!err) {
+            return cbk([503, 'UnexpectedErrorCheckingTaprootSupport', {err}]);
+          }
+
+          if (!res) {
+            return cbk([503, 'ExpectedResultForDerivationPathsRequest']);
+          }
+
+          if (!isArray(res.accounts)) {
+            return cbk([503, 'ExpectedAccountsInDerivationPathsResult']);
+          }
+
+          if (!isTrSupported(res.accounts)) {
+            return cbk([501, 'ExpectedTaprootSupportingLndToCreateAddress']);
+          }
+
+          return cbk();
+        });
+      }],
+
       // Type
       type: ['validate', ({}, cbk) => {
         const format = args.format || defaultAddressFormat;
@@ -54,7 +90,7 @@ module.exports = (args, cbk) => {
       }],
 
       // Get the address
-      createAddress: ['type', ({type}, cbk) => {
+      createAddress: ['checkFormat', 'type', ({type}, cbk) => {
         return args.lnd.default.newAddress({type}, (err, res) => {
           if (!!err && err.message === connectFailMessage) {
             return cbk([503, 'FailedToConnectToDaemonToCreateChainAddress']);

package/lnd_methods/info/get_route_to_destination.js

@@ -129,6 +129,14 @@ module.exports = (args, cbk) => {
           return cbk([400, 'ExpectedLndApiObjectToGetRouteToDestination']);
         }
 
+        if (!!args.outgoing_channel) {
+          try {
+            chanNumber({channel: args.outgoing_channel});
+          } catch (err) {
+            return cbk([400, 'ExpectedStandardFormatChannelIdForOutChannel']);
+          }
+        }
+
         if (!!args.total_mtokens && !args.payment) {
           return cbk([400, 'ExpectedTotalMtokensWithPaymentIdentifier']);
         }

package/lnd_methods/macaroon/methods.json

@@ -34,6 +34,7 @@
     "type": "tower_client"
   },
   "createChainAddress": {
+    "depends_on": ["getMasterPublicKeys"],
     "method": "NewAddress",
     "type": "default"
   },

package/lnd_methods/peers/add_external_socket.d.ts

@@ -0,0 +1,20 @@
+import {
+  AuthenticatedLightningArgs,
+  AuthenticatedLightningMethod,
+} from '../../typescript/shared';
+
+export type AddExternalSocketArgs = AuthenticatedLightningArgs<{
+  /** Add Socket Address String */
+  socket: string;
+}>;
+
+/**
+ * Add a new advertised p2p socket address
+ *
+ * Note: this method is not supported in LND versions 0.14.3 and below
+ *
+ * Requires LND built with `peersrpc` build tag
+ *
+ * Requires `peers:write` permissions
+ */
+export const addExternalSocket: AuthenticatedLightningMethod<AddExternalSocketArgs>;

package/lnd_methods/peers/index.d.ts

@@ -1,4 +1,8 @@
+export * from './add_external_socket';
 export * from './add_peer';
 export * from './get_peers';
+export * from './remove_external_socket';
 export * from './remove_peer';
 export * from './subscribe_to_peers';
+export * from './update_alias';
+export * from './update_color';

package/lnd_methods/peers/remove_external_socket.d.ts

@@ -0,0 +1,20 @@
+import {
+  AuthenticatedLightningArgs,
+  AuthenticatedLightningMethod,
+} from '../../typescript/shared';
+
+export type RemoveExternalSocketArgs = AuthenticatedLightningArgs<{
+  /** Remove Socket Address String */
+  socket: string;
+}>;
+
+/**
+ * Remove an existing advertised p2p socket address
+ *
+ * Note: this method is not supported in LND versions 0.14.3 and below
+ *
+ * Requires LND built with `peersrpc` build tag
+ *
+ * Requires `peers:write` permissions
+ */
+export const removeExternalSocket: AuthenticatedLightningMethod<RemoveExternalSocketArgs>;

package/lnd_methods/peers/update_alias.d.ts

@@ -0,0 +1,11 @@
+import {
+  AuthenticatedLightningArgs,
+  AuthenticatedLightningMethod,
+} from '../../typescript/shared';
+
+export type UpdateAliasArgs = AuthenticatedLightningArgs<{
+  /** Node Alias String */
+  node: string;
+}>;
+
+export const updateAlias: AuthenticatedLightningMethod<UpdateAliasArgs>;

package/lnd_methods/peers/update_color.d.ts

@@ -0,0 +1,11 @@
+import {
+  AuthenticatedLightningArgs,
+  AuthenticatedLightningMethod,
+} from '../../typescript/shared';
+
+export type UpdateColorArgs = AuthenticatedLightningArgs<{
+  /** Node Color String */
+  color: string;
+}>;
+
+export const updateColor: AuthenticatedLightningMethod<UpdateColorArgs>;

package/lnd_methods/signer/begin_group_signing_session.d.ts

@@ -0,0 +1,33 @@
+import {
+  AuthenticatedLightningArgs,
+  AuthenticatedLightningMethod,
+} from '../../typescript/shared';
+
+export type BeginGroupSigningSessionArgs = AuthenticatedLightningArgs<{
+  /** Key Is BIP 86 Key Spend Key Bool */
+  is_key_spend?: boolean;
+  /** HD Seed Key Family Number */
+  key_family: number;
+  /** Key Index Number */
+  key_index: number;
+  /** External Public Key Hex String */
+  public_keys: string[];
+  /** Taproot Script Root Hash Hex String */
+  root_hash?: string;
+}>;
+
+export type BeginGroupSigningSessionResult = {
+  /** Final Script or Top Level Public Key Hex String */
+  external_key: string;
+  /** Session Id Hex String */
+  id: string;
+  /** Internal Top Level Public Key Hex String */
+  internal_key?: string;
+  /** Session Compound Nonces Hex String */
+  nonce: string;
+};
+
+export const beginGroupSigningSession: AuthenticatedLightningMethod<
+  BeginGroupSigningSessionArgs,
+  BeginGroupSigningSessionResult
+>;

package/lnd_methods/signer/end_group_signing_session.d.ts

@@ -0,0 +1,21 @@
+import {
+  AuthenticatedLightningArgs,
+  AuthenticatedLightningMethod,
+} from '../../typescript/shared';
+
+export type EndGroupSigningSessionArgs = AuthenticatedLightningArgs<{
+  /** Session Id Hex String */
+  id: string;
+  /** Combine External Partial Signature Hex Strings */
+  signatures?: string[];
+}>;
+
+export type EndGroupSigningSessionResult = {
+  /** Combined Signature Hex String */
+  signature?: string;
+};
+
+export const endGroupSigningSession: AuthenticatedLightningMethod<
+  EndGroupSigningSessionArgs,
+  EndGroupSigningSessionResult
+>;

package/lnd_methods/signer/index.d.ts

@@ -1,4 +1,7 @@
+export * from './begin_group_signing_session';
 export * from './diffie_hellman_compute_secret';
+export * from './end_group_signing_session';
 export * from './sign_bytes';
 export * from './sign_transaction';
+export * from './update_group_signing_session';
 export * from './verify_bytes_signature';

package/lnd_methods/signer/input_signing_method.js

@@ -0,0 +1,42 @@
+const v0SpendMethod = 0;
+const v1Bip86Method = 1;
+const v1SpendMethod = 2;
+const v1ScriptSpend = 3;
+
+/** Determine a signing method for an input
+
+  {
+    input: [{
+      [root_hash]: <Taproot Root Hash Hex String>
+      [witness_script]: <Witness Script Hex String>
+    }]
+    [outputs]: [{
+      pk_script: <UTXO Output Script Buffer Object>
+      value: <UTXO Tokens Number>
+    }]
+  }
+
+  @returns
+  {
+    method: <Signing Method Number>
+  }
+*/
+module.exports = ({input, outputs}, cbk) => {
+  // Exit early when lack of previous outputs indicates a v0 spend
+  if (!outputs) {
+    return {method: v0SpendMethod};
+  }
+
+  // Exit early when no leaf script or script commitment is present
+  if (!input.root_hash && !input.witness_script) {
+    return {method: v1Bip86Method};
+  }
+
+  // Exit early when there is no leaf script, just a top level key spend
+  if (!input.witness_script) {
+    return {method: v1SpendMethod};
+  }
+
+  // Sign for a leaf script for a key that commits to the scripts root hash
+  return {method: v1ScriptSpend};
+};

package/lnd_methods/signer/sign_transaction.d.ts

@@ -13,12 +13,14 @@ export type SignTransactionArgs = AuthenticatedLightningArgs<{
     output_script: string;
     /** Output Tokens */
     output_tokens: number;
+    /** Taproot Root Hash Hex String */
+    root_hash?: string;
     /** Sighash Type */
     sighash: number;
     /** Input Index To Sign */
     vin: number;
     /** Witness Script Hex String */
-    witness_script: string;
+    witness_script?: string;
   }[];
   spending?: {
     /** Non-Internal Spend Output Script Hex String */

package/lnd_methods/signer/sign_transaction.js

@@ -1,10 +1,11 @@
 const asyncAuto = require('async/auto');
 const {returnResult} = require('asyncjs-util');
 
+const inputSigningMethod = require('./input_signing_method');
 const {isLnd} = require('./../../lnd_requests');
 
 const bufferAsHex = buffer => buffer.toString('hex');
-const hexAsBuffer = hex => Buffer.from(hex, 'hex');
+const hexAsBuffer = hex => Buffer.from(hex || '', 'hex');
 const {isArray} = Array;
 const isV1 = scriptHex => scriptHex.length === 68 && /5120/.test(scriptHex);
 const method = 'signOutputRaw';
@@ -20,6 +21,7 @@ const unimplementedError = '12 UNIMPLEMENTED: unknown service signrpc.Signer';
 
   Requires `signer:generate` permission
 
+  `root_hash` is not supported in LND 0.14.3 and below
   `spending` is not supported in LND 0.14.3 and below
 
   {
@@ -28,9 +30,10 @@ const unimplementedError = '12 UNIMPLEMENTED: unknown service signrpc.Signer';
       key_index: <Key Index Number>
       output_script: <Output Script Hex String>
       output_tokens: <Output Tokens Number>
+      [root_hash]: <Taproot Root Hash Hex String>
       sighash: <Sighash Type Number>
       vin: <Input Index To Sign Number>
-      witness_script: <Witness Script Hex String>
+      [witness_script]: <Witness Script Hex String>
     }]
     lnd: <Authenticated LND API Object>
     [spending]: [{
@@ -65,8 +68,8 @@ module.exports = ({inputs, lnd, spending, transaction}, cbk) => {
         return cbk();
       },
 
-      // Derive the previous outputs set
-      previousOutputs: ['validate', ({}, cbk) => {
+      // Derive the previous outputs set for Taproot spends
+      outputs: ['validate', ({}, cbk) => {
         const outputs = [].concat(inputs).concat(spending || []).map(utxo => ({
           pk_script: hexAsBuffer(utxo.output_script),
           value: utxo.output_tokens,
@@ -83,25 +86,29 @@ module.exports = ({inputs, lnd, spending, transaction}, cbk) => {
       }],
 
       // Get signatures
-      signTransaction: ['previousOutputs', ({previousOutputs}, cbk) => {
+      signTransaction: ['outputs', ({outputs}, cbk) => {
         return lnd[type][method]({
-          prev_outputs: previousOutputs,
+          prev_outputs: outputs,
           raw_tx_bytes: hexAsBuffer(transaction),
-          sign_descs: inputs.map(input => ({
-            input_index: input.vin,
-            key_desc: {
-              key_loc: {
-                key_family: input.key_family,
-                key_index: input.key_index,
+          sign_descs: inputs.map(input => {
+            return {
+              input_index: input.vin,
+              key_desc: {
+                key_loc: {
+                  key_family: input.key_family,
+                  key_index: input.key_index,
+                },
               },
-            },
-            output: {
-              pk_script: hexAsBuffer(input.output_script),
-              value: input.output_tokens,
-            },
-            sighash: input.sighash,
-            witness_script: hexAsBuffer(input.witness_script),
-          })),
+              output: {
+                pk_script: hexAsBuffer(input.output_script),
+                value: input.output_tokens,
+              },
+              sighash: input.sighash,
+              sign_method: inputSigningMethod({input, outputs}).method,
+              tap_tweak: hexAsBuffer(input.root_hash),
+              witness_script: hexAsBuffer(input.witness_script),
+            };
+          }),
         },
         (err, res) => {
           if (!!err && err.message === unimplementedError) {

package/lnd_methods/signer/update_group_signing_session.d.ts

@@ -0,0 +1,23 @@
+import {
+  AuthenticatedLightningArgs,
+  AuthenticatedLightningMethod,
+} from '../../typescript/shared';
+
+export type UpdateGroupSigningSessionArgs = AuthenticatedLightningArgs<{
+  /** Hash to Sign Hex String */
+  hash: string;
+  /** MuSig2 Session Id Hex String */
+  id: string;
+  /** Nonce Hex Strings */
+  nonces: string[];
+}>;
+
+export type UpdateGroupSigningSessionResult = {
+  /** Partial Signature Hex String */
+  signature: string;
+};
+
+export const updateGroupSigningSession: AuthenticatedLightningMethod<
+  UpdateGroupSigningSessionArgs,
+  UpdateGroupSigningSessionResult
+>;

package/package.json

@@ -10,13 +10,13 @@
     "@grpc/grpc-js": "1.6.7",
     "@grpc/proto-loader": "0.6.12",
     "@types/express": "4.17.13",
-    "@types/node": "17.0.31",
+    "@types/node": "17.0.38",
     "@types/request": "2.48.8",
     "@types/ws": "8.5.3",
     "async": "3.2.3",
     "asyncjs-util": "1.2.9",
     "bitcoinjs-lib": "6.0.1",
-    "bn.js": "5.2.0",
+    "bn.js": "5.2.1",
     "body-parser": "1.20.0",
     "bolt07": "1.8.1",
     "bolt09": "0.2.3",
@@ -24,17 +24,17 @@
     "ecpair": "2.0.1",
     "express": "4.18.1",
     "invoices": "2.0.6",
-    "psbt": "2.0.1",
+    "psbt": "2.3.0",
     "tiny-secp256k1": "2.2.1",
-    "type-fest": "2.12.2"
+    "type-fest": "2.13.0"
   },
   "description": "Lightning Network client library",
   "devDependencies": {
     "@alexbosworth/node-fetch": "2.6.2",
     "@alexbosworth/tap": "15.0.11",
     "tsd": "0.20.0",
-    "typescript": "4.6.4",
-    "ws": "8.6.0"
+    "typescript": "4.7.2",
+    "ws": "8.7.0"
   },
   "engines": {
     "node": ">=12.20"
@@ -59,5 +59,5 @@
     "directory": "test/typescript"
   },
   "types": "index.d.ts",
-  "version": "5.15.1"
+  "version": "5.16.1"
 }

package/test/lnd_methods/address/test_create_chain_address.js

@@ -66,6 +66,93 @@ const tests = [
     description: 'An address is required',
     expected: {address: 'addr'},
   },
+  {
+    args: {
+      lnd: {default: {newAddress: ({}, cbk) => cbk(null, {address: 'addr'})}},
+    },
+    description: 'The default address is p2wpkh',
+    expected: {address: 'addr'},
+  },
+  {
+    args: {
+      format: 'p2tr',
+      lnd: {
+        default: {
+          newAddress: ({}, cbk) => cbk(null, {address: 'addr'}),
+        },
+        wallet: {
+          listAccounts: ({}, cbk) => cbk({
+            details: 'unknown.service.walletrpc.WalletKit',
+          }),
+        },
+      },
+    },
+    description: 'Taproot requires TR account',
+    error: [501, 'CreationOfTaprootAddressesUnsupported'],
+  },
+  {
+    args: {
+      format: 'p2tr',
+      lnd: {
+        default: {newAddress: ({}, cbk) => cbk(null, {address: 'addr'})},
+        wallet: {listAccounts: ({}, cbk) => cbk('err')},
+      },
+    },
+    description: 'Taproot check errors are passed back',
+    error: [503, 'UnexpectedErrorCheckingTaprootSupport'],
+  },
+  {
+    args: {
+      format: 'p2tr',
+      lnd: {
+        default: {newAddress: ({}, cbk) => cbk(null, {address: 'addr'})},
+        wallet: {listAccounts: ({}, cbk) => cbk()},
+      },
+    },
+    description: 'Taproot requires account result',
+    error: [503, 'ExpectedResultForDerivationPathsRequest'],
+  },
+  {
+    args: {
+      format: 'p2tr',
+      lnd: {
+        default: {newAddress: ({}, cbk) => cbk(null, {address: 'addr'})},
+        wallet: {listAccounts: ({}, cbk) => cbk(null, {})},
+      },
+    },
+    description: 'Taproot accounts are expected',
+    error: [503, 'ExpectedAccountsInDerivationPathsResult'],
+  },
+  {
+    args: {
+      format: 'p2tr',
+      lnd: {
+        default: {newAddress: ({}, cbk) => cbk(null, {address: 'addr'})},
+        wallet: {listAccounts: ({}, cbk) => cbk(null, {accounts: []})},
+      },
+    },
+    description: 'Taproot supporting account is expected',
+    error: [501, 'ExpectedTaprootSupportingLndToCreateAddress'],
+  },
+  {
+    args: {
+      format: 'p2tr',
+      lnd: {
+        default: {
+          newAddress: ({}, cbk) => cbk(null, {
+            address: 'taproot_address',
+          }),
+        },
+        wallet: {
+          listAccounts: ({}, cbk) => cbk(null, {
+            accounts: [{address_type: 'TAPROOT_PUBKEY'}],
+          }),
+        },
+      },
+    },
+    description: 'Taproot supporting account',
+    expected: {address: 'taproot_address'},
+  },
   {
     args: {
       format: 'p2wpkh',

package/test/lnd_methods/info/test_get_route_to_destination.js

@@ -70,6 +70,11 @@ const makeArgs = override => {
 };
 
 const tests = [
+  {
+    args: makeArgs({confidence: NaN}),
+    description: 'Valid confidence is required',
+    error: [400, 'ExpectedConfidenceInPartsPerMillionForQuery'],
+  },
   {
     args: makeArgs({destination: undefined}),
     description: 'A destination is required',
@@ -85,6 +90,11 @@ const tests = [
     description: 'LND is required',
     error: [400, 'ExpectedLndApiObjectToGetRouteToDestination'],
   },
+  {
+    args: makeArgs({outgoing_channel: 12345}),
+    description: 'Outgoing channel is expected in standard format',
+    error: [400, 'ExpectedStandardFormatChannelIdForOutChannel'],
+  },
   {
     args: makeArgs({payment: undefined}),
     description: 'Total mtokens requires linking payment identifier',
@@ -132,6 +142,11 @@ const tests = [
     description: 'No route is found with error',
     expected: {},
   },
+  {
+    args: makeArgs({lnd: makeLnd({err: {details: 'is too large'}})}),
+    description: 'Payment cannot exceed maximum size',
+    error: [400, 'PaymentTooLargeToFindRoute'],
+  },
   {
     args: makeArgs({lnd: makeLnd({res: {routes: []}})}),
     description: 'No route is found',

package/test/lnd_methods/signer/test_input_signing_method.js

@@ -0,0 +1,53 @@
+const {test} = require('@alexbosworth/tap');
+
+const method = require('./../../../lnd_methods/signer/input_signing_method');
+
+const makeArgs = override => {
+  const args = {
+    input: {
+      root_hash: '00',
+      witness_script: '00',
+    },
+    outputs: [{
+      pk_script: Buffer.alloc(1),
+      value: 1,
+    }],
+  };
+
+  Object.keys(override || {}).forEach(key => args[key] = override[key]);
+
+  return args;
+};
+
+const tests = [
+  {
+    args: makeArgs({}),
+    description: 'Input signing method is returned for a leaf spend',
+    expected: {method: 3},
+  },
+  {
+    args: makeArgs({input: {}, outputs: undefined}),
+    description: 'Input signing method is returned for a regular spend',
+    expected: {method: 0},
+  },
+  {
+    args: makeArgs({input: {}}),
+    description: 'Input signing method is returned for a bip86 spend',
+    expected: {method: 1},
+  },
+  {
+    args: makeArgs({input: {root_hash: '00'}}),
+    description: 'Input signing method is returned for a top key script spend',
+    expected: {method: 2},
+  },
+];
+
+tests.forEach(({args, description, expected}) => {
+  return test(description, async ({end, strictSame}) => {
+    const res = method(args);
+
+    strictSame(res, expected, 'Got expected result');
+
+    return end();
+  });
+});

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

@@ -0,0 +1,14 @@
+import {expectError, expectType} from 'tsd';
+import {addExternalSocket} from '../../lnd_methods';
+import {AuthenticatedLnd} from '../../lnd_grpc';
+
+const lnd = {} as AuthenticatedLnd;
+const socket = 'socket';
+
+expectError(addExternalSocket());
+expectError(addExternalSocket({}));
+expectError(addExternalSocket({lnd}));
+expectError(addExternalSocket({socket}));
+
+expectType<void>(await addExternalSocket({lnd, socket}));
+expectType<void>(addExternalSocket({lnd, socket}, () => {}));

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

@@ -0,0 +1,60 @@
+import {expectError, expectType} from 'tsd';
+import {
+  beginGroupSigningSession,
+  BeginGroupSigningSessionResult,
+} from '../../lnd_methods';
+import {AuthenticatedLnd} from '../../lnd_grpc';
+
+const lnd = {} as AuthenticatedLnd;
+const is_key_spend = true;
+const key_family = 0;
+const key_index = 0;
+const public_keys = ['pubkey'];
+const root_hash = 'root hash';
+
+expectError(beginGroupSigningSession());
+expectError(beginGroupSigningSession({}));
+expectError(beginGroupSigningSession({lnd}));
+expectError(beginGroupSigningSession({key_family}));
+expectError(beginGroupSigningSession({key_index}));
+expectError(beginGroupSigningSession({public_keys}));
+expectError(beginGroupSigningSession({lnd, key_family}));
+expectError(beginGroupSigningSession({lnd, key_index}));
+expectError(beginGroupSigningSession({lnd, public_keys}));
+expectError(beginGroupSigningSession({key_family, key_index}));
+expectError(beginGroupSigningSession({key_family, public_keys}));
+expectError(beginGroupSigningSession({key_index, public_keys}));
+expectError(beginGroupSigningSession({lnd, key_family, key_index}));
+expectError(beginGroupSigningSession({lnd, key_family, public_keys}));
+expectError(beginGroupSigningSession({lnd, key_index, public_keys}));
+expectError(beginGroupSigningSession({key_family, key_index, public_keys}));
+
+expectType<BeginGroupSigningSessionResult>(
+  await beginGroupSigningSession({lnd, key_family, key_index, public_keys})
+);
+expectType<BeginGroupSigningSessionResult>(
+  await beginGroupSigningSession({
+    lnd,
+    key_family,
+    key_index,
+    public_keys,
+    is_key_spend,
+    root_hash,
+  })
+);
+expectType<void>(
+  beginGroupSigningSession(
+    {lnd, key_family, key_index, public_keys},
+    (err, res) => {
+      expectType<BeginGroupSigningSessionResult>(res);
+    }
+  )
+);
+expectType<void>(
+  beginGroupSigningSession(
+    {lnd, key_family, key_index, public_keys, is_key_spend, root_hash},
+    (err, res) => {
+      expectType<BeginGroupSigningSessionResult>(res);
+    }
+  )
+);

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

@@ -0,0 +1,32 @@
+import {expectError, expectType} from 'tsd';
+import {
+  endGroupSigningSession,
+  EndGroupSigningSessionResult,
+} from '../../lnd_methods';
+import {AuthenticatedLnd} from '../../lnd_grpc';
+
+const lnd = {} as AuthenticatedLnd;
+const id = 'id';
+const signatures = ['signature'];
+
+expectError(endGroupSigningSession());
+expectError(endGroupSigningSession({}));
+expectError(endGroupSigningSession({lnd}));
+expectError(endGroupSigningSession({id}));
+
+expectType<EndGroupSigningSessionResult>(
+  await endGroupSigningSession({lnd, id})
+);
+expectType<EndGroupSigningSessionResult>(
+  await endGroupSigningSession({lnd, id, signatures})
+);
+expectType<void>(
+  endGroupSigningSession({lnd, id}, (err, res) => {
+    expectType<EndGroupSigningSessionResult>(res);
+  })
+);
+expectType<void>(
+  endGroupSigningSession({lnd, id, signatures}, (err, res) => {
+    expectType<EndGroupSigningSessionResult>(res);
+  })
+);

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

@@ -0,0 +1,14 @@
+import {expectError, expectType} from 'tsd';
+import {removeExternalSocket} from '../../lnd_methods';
+import {AuthenticatedLnd} from '../../lnd_grpc';
+
+const lnd = {} as AuthenticatedLnd;
+const socket = 'socket';
+
+expectError(removeExternalSocket());
+expectError(removeExternalSocket({}));
+expectError(removeExternalSocket({lnd}));
+expectError(removeExternalSocket({socket}));
+
+expectType<void>(await removeExternalSocket({lnd, socket}));
+expectType<void>(removeExternalSocket({lnd, socket}, () => {}));

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

@@ -11,7 +11,6 @@ const inputs = [
     output_tokens: 1,
     sighash: 1,
     vin: 0,
-    witness_script: '00',
   },
 ];
 const spending = [

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

@@ -0,0 +1,14 @@
+import {expectError, expectType} from 'tsd';
+import {updateAlias} from '../../lnd_methods';
+import {AuthenticatedLnd} from '../../lnd_grpc';
+
+const lnd = {} as AuthenticatedLnd;
+const node = 'node';
+
+expectError(updateAlias());
+expectError(updateAlias({}));
+expectError(updateAlias({lnd}));
+expectError(updateAlias({node}));
+
+expectType<void>(await updateAlias({lnd, node}));
+expectType<void>(updateAlias({lnd, node}, () => {}));

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

@@ -0,0 +1,14 @@
+import {expectError, expectType} from 'tsd';
+import {updateColor} from '../../lnd_methods';
+import {AuthenticatedLnd} from '../../lnd_grpc';
+
+const lnd = {} as AuthenticatedLnd;
+const color = 'color';
+
+expectError(updateColor());
+expectError(updateColor({}));
+expectError(updateColor({lnd}));
+expectError(updateColor({color}));
+
+expectType<void>(await updateColor({lnd, color}));
+expectType<void>(updateColor({lnd, color}, () => {}));

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

@@ -0,0 +1,29 @@
+import {expectError, expectType} from 'tsd';
+import {
+  updateGroupSigningSession,
+  UpdateGroupSigningSessionResult,
+} from '../../lnd_methods';
+import {AuthenticatedLnd} from '../../lnd_grpc';
+
+const lnd = {} as AuthenticatedLnd;
+const hash = 'hash';
+const id = 'id';
+const nonces = ['nonce'];
+
+expectError(updateGroupSigningSession());
+expectError(updateGroupSigningSession({}));
+expectError(updateGroupSigningSession({lnd}));
+expectError(updateGroupSigningSession({hash}));
+expectError(updateGroupSigningSession({id}));
+expectError(updateGroupSigningSession({nonces}));
+expectError(updateGroupSigningSession({lnd, hash}));
+expectError(updateGroupSigningSession({lnd, id}));
+expectError(updateGroupSigningSession({lnd, nonces}));
+expectError(updateGroupSigningSession({lnd, hash, id}));
+expectError(updateGroupSigningSession({lnd, hash, nonces}));
+expectError(updateGroupSigningSession({lnd, id, nonces}));
+
+expectType<UpdateGroupSigningSessionResult>(
+  await updateGroupSigningSession({lnd, hash, id, nonces})
+);
+expectType<void>(updateGroupSigningSession({lnd, hash, id, nonces}, () => {}));