lightning 5.15.0 → 5.16.0

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Versions
 
+## 5.16.0
+
+- `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
+    `failed_at` dates for attempt start and attempt failed dates.
+
 ## 5.15.0
 
 - `beginGroupSigningSession`: Add method to start a MuSig2 signing session

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/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/offchain/get_failed_payments.js

@@ -56,7 +56,9 @@ const type = 'default';
           message: <Error Message String>
         }
         [index]: <Payment Add Index Number>
-        [confirmed_at]: <Payment Confirmed At ISO 8601 Date String>
+        [confirmed_at]: <Payment Attempt Succeeded At ISO 8601 Date String>
+        created_at: <Attempt Was Started At ISO 8601 Date String>
+        [failed_at]: <Payment Attempt Failed At ISO 8601 Date String>
         is_confirmed: <Payment Attempt Succeeded Bool>
         is_failed: <Payment Attempt Failed Bool>
         is_pending: <Payment Attempt is Waiting For Resolution Bool>

package/lnd_methods/offchain/get_payments.js

@@ -55,7 +55,9 @@ const type = 'default';
           message: <Error Message String>
         }
         [index]: <Payment Add Index Number>
-        [confirmed_at]: <Payment Confirmed At ISO 8601 Date String>
+        [confirmed_at]: <Payment Attempt Succeeded At ISO 8601 Date String>
+        created_at: <Attempt Was Started At ISO 8601 Date String>
+        [failed_at]: <Payment Attempt Failed At ISO 8601 Date String>
         is_confirmed: <Payment Attempt Succeeded Bool>
         is_failed: <Payment Attempt Failed Bool>
         is_pending: <Payment Attempt is Waiting For Resolution Bool>

package/lnd_methods/offchain/get_pending_payments.js

@@ -57,6 +57,8 @@ const type = 'default';
         }
         [index]: <Payment Add Index Number>
         [confirmed_at]: <Payment Confirmed At ISO 8601 Date String>
+        created_at: <Attempt Was Started At ISO 8601 Date String>
+        [failed_at]: <Payment Attempt Failed At ISO 8601 Date String>
         is_confirmed: <Payment Attempt Succeeded Bool>
         is_failed: <Payment Attempt Failed Bool>
         is_pending: <Payment Attempt is Waiting For Resolution Bool>

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.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';
@@ -28,9 +29,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 +67,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 +85,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/lnd_responses/rpc_attempt_htlc_as_attempt.js

@@ -61,7 +61,9 @@ const nsAsMs = ns => Number(BigInt(ns) / BigInt(1e6));
 
   @returns
   {
-    confirmed_at: <Payment Succeeded At ISO 8601 Date String>
+    [confirmed_at]: <Payment Attempt Succeeded At ISO 8601 Date String>
+    created_at: <Attempt Was Started At ISO 8601 Date String>
+    [failed_at]: <Payment Attempt Failed At ISO 8601 Date String>
     is_confirmed: <Payment Attempt Succeeded Bool>
     is_failed: <Payment Attempt Failed Bool>
     is_pending: <Payment Attempt is Waiting For Resolution Bool>
@@ -91,6 +93,10 @@ module.exports = attempt => {
     throw new Error('ExpectedRpcAttemptDetailsToDeriveAttempt');
   }
 
+  if (!attempt.attempt_time_ns) {
+    throw new Error('ExpectedRpcAttemptStartTimeNs');
+  }
+
   if (!attempt.resolve_time_ns) {
     throw new Error('ExpectedRpcAttemptResolveTimeNs');
   }
@@ -103,11 +109,39 @@ module.exports = attempt => {
     throw new Error('ExpectedAttemptStatusInRpcAttemptDetails');
   }
 
+  const route = rpcRouteAsRoute(attempt.route);
+
+  if (attempt.status === attemptStates.confirmed) {
+    return {
+      route,
+      confirmed_at: new Date(nsAsMs(attempt.resolve_time_ns)).toISOString(),
+      created_at: new Date(nsAsMs(attempt.attempt_time_ns)).toISOString(),
+      failed_at: undefined,
+      is_confirmed: true,
+      is_failed: false,
+      is_pending: false,
+    };
+  }
+
+  if (attempt.status === attemptStates.failed) {
+    return {
+      route,
+      confirmed_at: undefined,
+      created_at: new Date(nsAsMs(attempt.attempt_time_ns)).toISOString(),
+      failed_at: new Date(nsAsMs(attempt.resolve_time_ns)).toISOString(),
+      is_confirmed: false,
+      is_failed: true,
+      is_pending: false,
+    };
+  }
+
   return {
-    confirmed_at: new Date(nsAsMs(attempt.resolve_time_ns)).toISOString(),
-    is_confirmed: attempt.status === attemptStates.confirmed,
-    is_failed: attempt.status === attemptStates.failed,
+    route,
+    confirmed_at: undefined,
+    created_at: new Date(nsAsMs(attempt.attempt_time_ns)).toISOString(),
+    failed_at: undefined,
+    is_confirmed: false,
+    is_failed: false,
     is_pending: attempt.status === attemptStates.pending,
-    route: rpcRouteAsRoute(attempt.route),
   };
 };

package/lnd_responses/rpc_payment_as_payment.js

@@ -81,6 +81,9 @@ const routePublicKeys = route => route.hops.map(n => n.public_key);
   @returns
   {
     attempts: [{
+      [confirmed_at]: <Payment Attempt Succeeded At ISO 8601 Date String>
+      created_at: <Attempt Was Started At ISO 8601 Date String>
+      [failed_at]: <Payment Attempt Failed At ISO 8601 Date String>
       [failure]: {
         code: <Error Type Code Number>
         [details]: {
@@ -108,6 +111,9 @@ const routePublicKeys = route => route.hops.map(n => n.public_key);
         }
         message: <Error Message String>
       }
+      [confirmed_at]: <Payment Attempt Succeeded At ISO 8601 Date String>
+      created_at: <Attempt Was Started At ISO 8601 Date String>
+      [failed_at]: <Payment Attempt Failed At ISO 8601 Date String>
       is_confirmed: <Payment Attempt Succeeded Bool>
       is_failed: <Payment Attempt Failed Bool>
       is_pending: <Payment Attempt is Waiting For Resolution Bool>

package/package.json

@@ -10,7 +10,7 @@
     "@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.33",
     "@types/request": "2.48.8",
     "@types/ws": "8.5.3",
     "async": "3.2.3",
@@ -59,5 +59,5 @@
     "directory": "test/typescript"
   },
   "types": "index.d.ts",
-  "version": "5.15.0"
+  "version": "5.16.0"
 }

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/offchain/test_get_payments.js

@@ -65,6 +65,8 @@ const makeExpectedPayment = ({}) => {
     destination: '020202020202020202020202020202020202020202020202020202020202020202',
     attempts: [{
       confirmed_at: '1970-01-01T00:00:00.000Z',
+      created_at: '1970-01-01T00:00:00.000Z',
+      failed_at: undefined,
       is_confirmed: true,
       is_failed: false,
       is_pending: false,

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/lnd_responses/test_rpc_attempt_htlc_as_attempt.js

@@ -19,7 +19,12 @@ const route = {
 };
 
 const makeArgs = overrides => {
-  const args = {route, resolve_time_ns: '1', status: 'IN_FLIGHT'};
+  const args = {
+    route,
+    attempt_time_ns: '1',
+    resolve_time_ns: '1',
+    status: 'IN_FLIGHT',
+  };
 
   Object.keys(overrides).forEach(k => args[k] = overrides[k]);
 
@@ -29,6 +34,8 @@ const makeArgs = overrides => {
 const makeExpected = overrides => {
   const attempt = {
     confirmed_at: '1970-01-01T00:00:00.000Z',
+    created_at: '1970-01-01T00:00:00.000Z',
+    failed_at: undefined,
     is_confirmed: false,
     is_failed: false,
     is_pending: false,
@@ -64,6 +71,11 @@ const tests = [
     description: 'An rpc attempt is required to map to an attempt',
     error: 'ExpectedRpcAttemptDetailsToDeriveAttempt',
   },
+  {
+    args: makeArgs({attempt_time_ns: undefined}),
+    description: 'Expected attempt time in rpc attempt details',
+    error: 'ExpectedRpcAttemptStartTimeNs',
+  },
   {
     args: makeArgs({resolve_time_ns: undefined}),
     description: 'Expected resolve time in rpc attempt details',
@@ -82,7 +94,7 @@ const tests = [
   {
     args: makeArgs({}),
     description: 'An in flight rpc attempt is mapped to an attempt',
-    expected: makeExpected({is_pending: true}),
+    expected: makeExpected({confirmed_at: undefined, is_pending: true}),
   },
   {
     args: makeArgs({status: 'SUCCEEDED'}),
@@ -92,7 +104,11 @@ const tests = [
   {
     args: makeArgs({status: 'FAILED'}),
     description: 'An rpc attempt is mapped to an attempt',
-    expected: makeExpected({is_failed: true}),
+    expected: makeExpected({
+      confirmed_at: undefined,
+      failed_at: '1970-01-01T00:00:00.000Z',
+      is_failed: true,
+    }),
   },
 ];
 

package/test/lnd_responses/test_rpc_payment_as_payment.js

@@ -73,7 +73,9 @@ const makeArgs = overrides => {
 const makeExpected = overrides => {
   const expected = {
     attempts: [{
-      confirmed_at: '1970-01-01T00:00:00.001Z',
+      confirmed_at: undefined,
+      created_at: '1970-01-01T00:00:00.001Z',
+      failed_at: '1970-01-01T00:00:00.001Z',
       is_confirmed: false,
       is_failed: true,
       is_pending: false,
@@ -272,6 +274,8 @@ const tests = [
     expected: makeExpected({
       attempts: [{
         confirmed_at: '2020-04-20T19:17:16.160Z',
+        created_at: '2020-04-20T19:17:15.428Z',
+        failed_at: undefined,
         is_confirmed: true,
         is_failed: false,
         is_pending: false,

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/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}, () => {}));