lightning 4.10.1 → 4.10.5

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Versions
 
+## 4.10.5
+
+- `getInvoice`, `getInvoices`, `subscribeToInvoice`, `subscribeToInvoices`:
+    Fix `payment` being set when undefined, correct `is_push` for AMP pushes
+
+## 4.10.3
+
+- `grantAccess`: Fix support for non-working methods
+
 ## 4.10.1
 
 - `getWalletVersion`: Add support for LND v0.13.3-beta

package/grpc/protos/lightning.proto

@@ -1086,6 +1086,12 @@ message SignMessageRequest {
     base64.
     */
     bytes msg = 1;
+
+    /*
+    Instead of the default double-SHA256 hashing of the message before signing,
+    only use one round of hashing instead.
+    */
+    bool single_hash = 2;
 }
 message SignMessageResponse {
     // The signature for the given message
@@ -2132,6 +2138,20 @@ message FundingPsbtVerify {
 
     // The pending channel ID of the channel to get the PSBT for.
     bytes pending_chan_id = 2;
+
+    /*
+    Can only be used if the no_publish flag was set to true in the OpenChannel
+    call meaning that the caller is solely responsible for publishing the final
+    funding transaction. If skip_finalize is set to true then lnd will not wait
+    for a FundingPsbtFinalize state step and instead assumes that a transaction
+    with the same TXID as the passed in PSBT will eventually confirm.
+    IT IS ABSOLUTELY IMPERATIVE that the TXID of the transaction that is
+    eventually published does have the _same TXID_ as the verified PSBT. That
+    means no inputs or outputs can change, only signatures can be added. If the
+    TXID changes between this call and the publish step then the channel will
+    never be created and the funds will be in limbo.
+    */
+    bool skip_finalize = 3;
 }
 
 message FundingPsbtFinalize {

package/grpc/protos/signer.proto

@@ -190,6 +190,9 @@ message SignMessageReq {
 
     // The key locator that identifies which key to use for signing.
     KeyLocator key_loc = 2;
+
+    // Double-SHA256 hash instead of just the default single round.
+    bool double_hash = 3;
 }
 message SignMessageResp {
     /*

package/lnd_messages/close_channel_request.js

@@ -0,0 +1,35 @@
+const hashAsTxId = hash => hash.slice().reverse().toString('hex');
+
+/** Derive open channel details from an open channel request gRPC message
+
+  {
+    channel_point: {
+      funding_txid_bytes: <Internal Byte Order Transaction Hash Buffer Object>
+      output_index: <Transaction Output Index Number>
+    }
+    delivery_address: <Request Cooperative Close Address String>
+    force: <Force Close Channel Bool>
+    sat_per_byte: <Chain Fee Tokens Per Virtual Byte String>
+    target_conf: <Target Confirm Within N Blocks Number>
+  }
+
+  @returns
+  {
+    [address]: <Request Sending Local Channel Funds To Address String>
+    [is_force_close]: <Is Force Close Bool>
+    [target_confirmations]: <Confirmation Target Number>
+    [tokens_per_vbyte]: <Tokens Per Virtual Byte Number>
+    transaction_id: <Transaction Id Hex String>
+    transaction_vout: <Transaction Output Index Number>
+  }
+*/
+module.exports = args => {
+  return {
+    address: args.delivery_address || undefined,
+    is_force_close: args.force || undefined,
+    target_confirmations: args.target_conf || undefined,
+    tokens_per_vbyte: Number(args.sat_per_byte) || undefined,
+    transaction_id: hashAsTxId(args.channel_point.funding_txid_bytes),
+    transaction_vout: args.channel_point.output_index,
+  };
+};

package/lnd_messages/index.js

@@ -0,0 +1,5 @@
+const closeChannelRequest = require('./close_channel_request');
+const openChannelRequest = require('./open_channel_request');
+const payViaRouteRequest = require('./pay_via_route_request');
+
+module.exports = {closeChannelRequest, openChannelRequest, payViaRouteRequest};

package/lnd_messages/open_channel_request.js

@@ -0,0 +1,51 @@
+const bufferAsHex = buffer => buffer.toString('hex');
+const minConfs = (isZero, confs) => isZero ? Number() : (confs || undefined);
+
+/** Derive open channel details from an open channel request gRPC message
+
+  {
+    close_address: <Cooperative Close Address String>
+    local_funding_amount: <Channel Capacity Tokens String>
+    min_htlc_msat: <Minimum HTLC Millitokens String>
+    node_pubkey: <Node Public Key Buffer Object>
+    node_pubkey_string: <Node Public Key Hex String>
+    private: <Channel Is Private Bool>
+    push_sat: <Gift Tokens String>
+    remote_csv_delay: <Peer Uncooperative Output CSV Delay Blocks Number>
+    sat_per_byte: <Tokens Per Virtual Byte String>
+    sat_per_vbyte: <Tokens Per Virtual Byte String>
+    spend_unconfirmed: <Spend Unconfirmed UTXOs Bool>
+    target_conf: <Funding Transaction Confirmation Target Number>
+  }
+
+  @returns
+  {
+    [chain_fee_tokens_per_vbyte]: <Chain Fee Tokens Per VByte Number>
+    [cooperative_close_address]: <Restrict Cooperative Close To Address String>
+    [give_tokens]: <Tokens to Gift To Partner Number>
+    [is_private]: <Channel is Private Bool>
+    local_tokens: <Local Tokens Number>
+    [min_confirmations]: <Spend UTXOs With Minimum Confirmations Number>
+    [min_htlc_mtokens]: <Minimum HTLC Millitokens String>
+    partner_public_key: <Public Key Hex String>
+    [partner_csv_delay]: <Peer Output CSV Delay Number>
+  }
+*/
+module.exports = args => {
+  const feeRate = Number(args.sat_per_vbyte) || Number(args.sat_per_byte);
+  const hasMinHtlc = args.min_htlc_msat !== Number().toString();
+  const publicKey = bufferAsHex(args.node_pubkey) || args.node_pubkey_string;
+  const utxoConfs = minConfs(args.spend_unconfirmed, args.min_confirmations);
+
+  return {
+    chain_fee_tokens_per_vbyte: feeRate || undefined,
+    cooperative_close_address: args.close_address || undefined,
+    give_tokens: Number(args.push_sat) || undefined,
+    is_private: args.private || undefined,
+    local_tokens: Number(args.local_funding_amount),
+    min_confirmations: utxoConfs,
+    min_htlc_mtokens: hasMinHtlc ? args.min_htlc_msat : undefined,
+    partner_public_key: publicKey,
+    partner_csv_delay: args.remote_csv_delay || undefined,
+  };
+};

package/lnd_messages/pay_via_route_request.js

@@ -0,0 +1,61 @@
+const {rpcRouteAsRoute} = require('./../lnd_responses');
+
+const bufferAsHex = buffer => buffer.toString('hex');
+
+/** Derive payment details from a pay via route request
+
+  {
+    payment_hash: <Payment Hash Buffer Object>
+    route: {
+      hops: [{
+        amt_to_forward_msat: <Millitokens to Forward String>
+        chan_id: <Numeric Format Channel Id String>
+        chan_capacity: <Channel Capacity Number>
+        custom_records: {
+          <UInt64 String>: <Record Data Buffer>
+        }
+        expiry: <Timeout Chain Height Number>
+        fee_msat: <Fee in Millitokens String>
+        [mpp_record]: {
+          payment_addr: <Payment Identifier Buffer>
+          total_amt_msat: <Total Payment Millitokens Amount String>
+        }
+        [pub_key]: <Next Hop Public Key Hex String>
+        tlv_payload: <Has Extra TLV Data Bool>
+      }]
+      total_amt_msat: <Route Total Millitokens String>
+      total_fees_msat: <Route Total Fees Millitokens String>
+      total_time_lock: <Route Total Timelock Number>
+    }
+  }
+
+  @returns
+  {
+    id: <Payment Hash Hex String>
+    route: {
+      fee: <Route Fee Tokens Number>
+      fee_mtokens: <Route Fee Millitokens String>
+      hops: [{
+        channel: <Standard Format Channel Id String>
+        channel_capacity: <Channel Capacity Tokens Number>
+        fee: <Fee Tokens Number>
+        fee_mtokens: <Fee Millitokens String>
+        forward: <Forward Tokens Number>
+        forward_mtokens: <Forward Millitokens String>
+        public_key: <Forward Edge Public Key Hex String>
+        [timeout]: <Timeout Block Height Number>
+      }]
+      mtokens: <Total Fee-Inclusive Millitokens String>
+      [payment]: <Payment Identifier Hex String>
+      [timeout]: <Timeout Block Height Number>
+      tokens: <Total Fee-Inclusive Tokens Number>
+      [total_mtokens]: <Total Payment Millitokens String>
+    }
+  }
+*/
+module.exports = args => {
+  return {
+    id: bufferAsHex(args.payment_hash),
+    route: rpcRouteAsRoute(args.route),
+  };
+};

package/lnd_methods/index.js

@@ -35,6 +35,7 @@ const {getChannelBalance} = require('./offchain');
 const {getChannels} = require('./offchain');
 const {getClosedChannels} = require('./offchain');
 const {getConnectedWatchtowers} = require('./offchain');
+const {getFailedPayments} = require('./offchain');
 const {getFeeRates} = require('./offchain');
 const {getForwardingConfidence} = require('./offchain');
 const {getForwardingReputations} = require('./offchain');
@@ -164,6 +165,7 @@ module.exports = {
   getChannels,
   getClosedChannels,
   getConnectedWatchtowers,
+  getFailedPayments,
   getFeeRates,
   getForwardingConfidence,
   getForwardingReputations,

package/lnd_methods/macaroon/accept_rpc_request.js

@@ -0,0 +1,44 @@
+const asyncAuto = require('async/auto');
+const {returnResult} = require('asyncjs-util');
+
+const feedback = {replace_response: false};
+
+/** Accept an RPC request
+
+  {
+    id: <Request or Response Id Number To Accept>
+    subscription: <RPC Request Stream Object>
+  }
+
+  @returns via cbk or Promise
+*/
+module.exports = ({id, subscription}, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!id) {
+          return cbk([400, 'ExpectedRequestIdToAcceptRpcRequest']);
+        }
+
+        if (!subscription) {
+          return cbk([400, 'ExpectedRpcSubscriptionToAcceptRpcRequest']);
+        }
+
+        return cbk();
+      },
+
+      // Send accept feedback to the stream
+      accept: ['validate', ({}, cbk) => {
+        return subscription.write({feedback, request_id: id}, err => {
+          if (!!err) {
+            return cbk([503, 'UnexpectedErrorAcceptingRpcRequest', {err}]);
+          }
+
+          return cbk();
+        });
+      }],
+    },
+    returnResult({reject, resolve}, cbk));
+  });
+};

package/lnd_methods/macaroon/handle_rpc_request_update.js

@@ -0,0 +1,148 @@
+const acceptRpcRequest = require('./accept_rpc_request');
+const {closeChannelRequest} = require('./../../lnd_messages');
+const {openChannelRequest} = require('./../../lnd_messages');
+const {payViaRouteRequest} = require('./../../lnd_messages');
+const rejectRpcRequest = require('./reject_rpc_request');
+const {rpcRequestUpdateAsEvent} = require('./../../lnd_responses');
+
+const isChanClose = n => !!n && n === '/lnrpc.Lightning/CloseChannel';
+const isChanOpen = n => !!n && n.startsWith('/lnrpc.Lightning/OpenChannel');
+const isPayViaRoute = n => !!n && n === '/routerrpc.Router/SendToRouteV2';
+
+/** Handle an update from the RPC request stream
+
+  {
+    [is_intercepting_close_channel_requests]: <Intercept Channel Closes Bool>
+    [is_intercepting_open_channel_requests]: <Is Handling Open Requests Bool>
+    [is_intercepting_pay_via_routes_requests]: <Is Handling Route Reqs Bool>
+    subscription: <Stream Subscription Object>
+    update: {
+      request_id: <Request Id Number String>
+      raw_macaroon: <Raw Macaroon Buffer Object>
+      custom_caveat_condition: <Custom Caveat Condition String>
+      [request]: {
+        method_full_uri: <Method URI String>
+        serialized: <Raw Protobuf Request Buffer Object>
+        stream_rpc: <Is String RPC Bool>
+        type_name: <RPC Message Type String>
+      }
+      [response]: {
+        method_full_uri: <Method URI String>
+        serialized: <Raw Protobuf Response Buffer Object>
+        stream_rpc: <Is String RPC Bool>
+        type_name: <RPC Message Type String>
+      }
+      [stream_auth]: {
+        method_full_uri: <Method URI String>
+      }
+      intercept_type: <RPC Update Type String>
+    }
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    [accept]: ({}, cbk) => {}
+    data: {
+      [accept]: ({}, cbk) => {}
+      id: <Request Id Number>
+      [macaroon]: <Base64 Encoded Macaroon String>
+      [reject]: ({}, cbk) => {}
+      [request]: {
+        [chain_fee_tokens_per_vbyte]: <Chain Fee Tokens Per VByte Number>
+        [cooperative_close_address]: <Prefer Cooperative Close To Address String>
+        [give_tokens]: <Tokens to Gift To Partner Number>
+        [is_private]: <Channel is Private Bool>
+        local_tokens: <Local Tokens Number>
+        [min_confirmations]: <Spend UTXOs With Minimum Confirmations Number>
+        [min_htlc_mtokens]: <Minimum HTLC Millitokens String>
+        partner_public_key: <Public Key Hex String>
+        [partner_csv_delay]: <Peer Output CSV Delay Number>
+      }
+      [uri]: <RPC URI String>
+    }
+    event: <Event Name String>
+  }
+*/
+module.exports = args => {
+  const details = rpcRequestUpdateAsEvent(args.update);
+  const isInterceptCloseChans = !!args.is_intercepting_close_channel_requests;
+  const isInterceptOpenChans = !!args.is_intercepting_open_channel_requests;
+  const isInterceptPayOnRoute = !!args.is_intercepting_pay_via_routes_requests;
+
+  const {event} = details;
+  const {id} = details;
+  const {macaroon} = details;
+  const {request} = args.update;
+  const {subscription} = args;
+  const {uri} = details;
+
+  const accept = ({}, cbk) => acceptRpcRequest({id, subscription}, cbk);
+
+  // Exit early when intercepting channel closes
+  if (!!isInterceptCloseChans && !!request && isChanClose(uri)) {
+    const req = args.lnd.default.CloseChannel.requestDeserialize(
+      args.update.request.serialized
+    );
+
+    return {
+      event: 'close_channel_request',
+      data: {
+        accept,
+        id,
+        macaroon,
+        uri,
+        reject: ({message}, cbk) => {
+          return rejectRpcRequest({id, message, subscription}, cbk);
+        },
+        request: closeChannelRequest(req),
+      },
+    };
+  }
+
+  // Exit early when intercepting channel opens
+  if (!!isInterceptOpenChans && !!request && isChanOpen(uri)) {
+    const req = args.lnd.default.OpenChannel.requestDeserialize(
+      args.update.request.serialized
+    );
+
+    return {
+      event: 'open_channel_request',
+      data: {
+        accept,
+        id,
+        macaroon,
+        uri,
+        reject: ({message}, cbk) => {
+          return rejectRpcRequest({id, message, subscription}, cbk);
+        },
+        request: openChannelRequest(req),
+      },
+    };
+  }
+
+  // Exit early when intercepting pay via route requests
+  if (!!isInterceptPayOnRoute && !!request && isPayViaRoute(uri)) {
+    const req = args.lnd.router.SendToRouteV2.requestDeserialize(
+      args.update.request.serialized
+    );
+
+    return {
+      event: 'pay_via_route_request',
+      data: {
+        accept,
+        id,
+        macaroon,
+        uri,
+        reject: ({message}, cbk) => {
+          return rejectRpcRequest({id, message, subscription}, cbk);
+        },
+        request: payViaRouteRequest(req),
+      },
+    };
+  }
+
+  return {accept, event, data: {id, macaroon, uri}};
+};

package/lnd_methods/macaroon/methods.json

@@ -139,6 +139,10 @@
     "methods": ["ListTowers", "Policy", "Stats"],
     "type": "tower_client"
   },
+  "getFailedPayments": {
+    "method": "ListPayments",
+    "type": "default"
+  },
   "getFeeRates": {
     "method": "FeeReport",
     "type": "default"
@@ -214,7 +218,7 @@
     "method": "WalletBalance",
     "type": "default"
   },
-  "getPendingChainBalance": {
+  "getPendingChannels": {
     "method": "PendingChannels",
     "type": "default"
   },
@@ -344,7 +348,7 @@
   },
   "setAutopilot": {
     "depends_on": ["getAutopilot"],
-    "methods": ["modifyStatus", "setScores"],
+    "methods": ["ModifyStatus", "SetScores"],
     "type": "autopilot"
   },
   "settleHodlInvoice": {
@@ -435,7 +439,7 @@
     "type": "router"
   },
   "subscribeToPayViaRoutes": {
-    "method": "sendToRouteV2",
+    "method": "SendToRouteV2",
     "type": "router"
   },
   "subscribeToPeers": {
@@ -462,11 +466,11 @@
     "type": "wallet"
   },
   "updateConnectedWatchtower": {
-    "methods": ["addTower", "removeTower"],
+    "methods": ["AddTower", "RemoveTower"],
     "type": "tower_client"
   },
   "updateChainTransaction": {
-    "method": "labelTransaction",
+    "method": "LabelTransaction",
     "type": "wallet"
   },
   "updatePathfindingSettings": {

package/lnd_methods/macaroon/reject_rpc_request.js

@@ -0,0 +1,52 @@
+const asyncAuto = require('async/auto');
+const {returnResult} = require('asyncjs-util');
+
+const defaultRejectMessage = 'RpcRequestRejected';
+
+/** Accept an RPC request
+
+  {
+    id: <Request or Response Id Number To Accept>
+    [message]: <Rejection Message String>
+    subscription: <RPC Request Stream Object>
+  }
+
+  @returns via cbk or Promise
+*/
+module.exports = ({id, message, subscription}, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!id) {
+          return cbk([400, 'ExpectedRequestIdToRejectRpcRequest']);
+        }
+
+        if (!subscription) {
+          return cbk([400, 'ExpectedRpcSubscriptionToRejectRpcRequest']);
+        }
+
+        return cbk();
+      },
+
+      // Send reject feedback to the stream
+      reject: ['validate', ({}, cbk) => {
+        return subscription.write({
+          feedback: {
+            error: message || defaultRejectMessage,
+            replace_response: false,
+          },
+          request_id: id,
+        },
+        err => {
+          if (!!err) {
+            return cbk([503, 'UnexpectedErrorRejectingRpcRequest', {err}]);
+          }
+
+          return cbk();
+        });
+      }],
+    },
+    returnResult({reject, resolve}, cbk));
+  });
+};