protos: update proto files for lnd v0.11.1 and loop v0.11.2

app/src/types/generated/lnd_pb.d.ts

@@ -2023,6 +2023,9 @@ export class OpenChannelRequest extends jspb.Message {
   getRemoteMaxValueInFlightMsat(): number;
   setRemoteMaxValueInFlightMsat(value: number): void;
 
+  getRemoteMaxHtlcs(): number;
+  setRemoteMaxHtlcs(value: number): void;
+
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): OpenChannelRequest.AsObject;
   static toObject(includeInstance: boolean, msg: OpenChannelRequest): OpenChannelRequest.AsObject;
@@ -2049,6 +2052,7 @@ export namespace OpenChannelRequest {
     closeAddress: string,
     fundingShim?: FundingShim.AsObject,
     remoteMaxValueInFlightMsat: number,
+    remoteMaxHtlcs: number,
   }
 }
 
@@ -2328,6 +2332,11 @@ export class FundingPsbtFinalize extends jspb.Message {
   getPendingChanId_asB64(): string;
   setPendingChanId(value: Uint8Array | string): void;
 
+  getFinalRawTx(): Uint8Array | string;
+  getFinalRawTx_asU8(): Uint8Array;
+  getFinalRawTx_asB64(): string;
+  setFinalRawTx(value: Uint8Array | string): void;
+
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): FundingPsbtFinalize.AsObject;
   static toObject(includeInstance: boolean, msg: FundingPsbtFinalize): FundingPsbtFinalize.AsObject;
@@ -2342,6 +2351,7 @@ export namespace FundingPsbtFinalize {
   export type AsObject = {
     signedPsbt: Uint8Array | string,
     pendingChanId: Uint8Array | string,
+    finalRawTx: Uint8Array | string,
   }
 }
 
@@ -4486,6 +4496,9 @@ export class AbandonChannelRequest extends jspb.Message {
   getChannelPoint(): ChannelPoint | undefined;
   setChannelPoint(value?: ChannelPoint): void;
 
+  getPendingFundingShimOnly(): boolean;
+  setPendingFundingShimOnly(value: boolean): void;
+
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): AbandonChannelRequest.AsObject;
   static toObject(includeInstance: boolean, msg: AbandonChannelRequest): AbandonChannelRequest.AsObject;
@@ -4499,6 +4512,7 @@ export class AbandonChannelRequest extends jspb.Message {
 export namespace AbandonChannelRequest {
   export type AsObject = {
     channelPoint?: ChannelPoint.AsObject,
+    pendingFundingShimOnly: boolean,
   }
 }
 
@@ -5247,6 +5261,63 @@ export namespace BakeMacaroonResponse {
   }
 }
 
+export class MacaroonPermissionList extends jspb.Message {
+  clearPermissionsList(): void;
+  getPermissionsList(): Array<MacaroonPermission>;
+  setPermissionsList(value: Array<MacaroonPermission>): void;
+  addPermissions(value?: MacaroonPermission, index?: number): MacaroonPermission;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): MacaroonPermissionList.AsObject;
+  static toObject(includeInstance: boolean, msg: MacaroonPermissionList): MacaroonPermissionList.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: MacaroonPermissionList, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): MacaroonPermissionList;
+  static deserializeBinaryFromReader(message: MacaroonPermissionList, reader: jspb.BinaryReader): MacaroonPermissionList;
+}
+
+export namespace MacaroonPermissionList {
+  export type AsObject = {
+    permissionsList: Array<MacaroonPermission.AsObject>,
+  }
+}
+
+export class ListPermissionsRequest extends jspb.Message {
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ListPermissionsRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: ListPermissionsRequest): ListPermissionsRequest.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: ListPermissionsRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ListPermissionsRequest;
+  static deserializeBinaryFromReader(message: ListPermissionsRequest, reader: jspb.BinaryReader): ListPermissionsRequest;
+}
+
+export namespace ListPermissionsRequest {
+  export type AsObject = {
+  }
+}
+
+export class ListPermissionsResponse extends jspb.Message {
+  getMethodPermissionsMap(): jspb.Map<string, MacaroonPermissionList>;
+  clearMethodPermissionsMap(): void;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ListPermissionsResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: ListPermissionsResponse): ListPermissionsResponse.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: ListPermissionsResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ListPermissionsResponse;
+  static deserializeBinaryFromReader(message: ListPermissionsResponse, reader: jspb.BinaryReader): ListPermissionsResponse;
+}
+
+export namespace ListPermissionsResponse {
+  export type AsObject = {
+    methodPermissionsMap: Array<[string, MacaroonPermissionList.AsObject]>,
+  }
+}
+
 export class Failure extends jspb.Message {
   getCode(): Failure.FailureCodeMap[keyof Failure.FailureCodeMap];
   setCode(value: Failure.FailureCodeMap[keyof Failure.FailureCodeMap]): void;
@@ -5401,6 +5472,66 @@ export namespace ChannelUpdate {
   }
 }
 
+export class MacaroonId extends jspb.Message {
+  getNonce(): Uint8Array | string;
+  getNonce_asU8(): Uint8Array;
+  getNonce_asB64(): string;
+  setNonce(value: Uint8Array | string): void;
+
+  getStorageid(): Uint8Array | string;
+  getStorageid_asU8(): Uint8Array;
+  getStorageid_asB64(): string;
+  setStorageid(value: Uint8Array | string): void;
+
+  clearOpsList(): void;
+  getOpsList(): Array<Op>;
+  setOpsList(value: Array<Op>): void;
+  addOps(value?: Op, index?: number): Op;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): MacaroonId.AsObject;
+  static toObject(includeInstance: boolean, msg: MacaroonId): MacaroonId.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: MacaroonId, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): MacaroonId;
+  static deserializeBinaryFromReader(message: MacaroonId, reader: jspb.BinaryReader): MacaroonId;
+}
+
+export namespace MacaroonId {
+  export type AsObject = {
+    nonce: Uint8Array | string,
+    storageid: Uint8Array | string,
+    opsList: Array<Op.AsObject>,
+  }
+}
+
+export class Op extends jspb.Message {
+  getEntity(): string;
+  setEntity(value: string): void;
+
+  clearActionsList(): void;
+  getActionsList(): Array<string>;
+  setActionsList(value: Array<string>): void;
+  addActions(value: string, index?: number): string;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): Op.AsObject;
+  static toObject(includeInstance: boolean, msg: Op): Op.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: Op, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): Op;
+  static deserializeBinaryFromReader(message: Op, reader: jspb.BinaryReader): Op;
+}
+
+export namespace Op {
+  export type AsObject = {
+    entity: string,
+    actionsList: Array<string>,
+  }
+}
+
 export interface AddressTypeMap {
   WITNESS_PUBKEY_HASH: 0;
   NESTED_PUBKEY_HASH: 1;

app/src/types/generated/lnd_pb_service.d.ts

@@ -508,6 +508,15 @@ type LightningBakeMacaroon = {
   readonly responseType: typeof lnd_pb.BakeMacaroonResponse;
 };
 
+type LightningListPermissions = {
+  readonly methodName: string;
+  readonly service: typeof Lightning;
+  readonly requestStream: false;
+  readonly responseStream: false;
+  readonly requestType: typeof lnd_pb.ListPermissionsRequest;
+  readonly responseType: typeof lnd_pb.ListPermissionsResponse;
+};
+
 export class Lightning {
   static readonly serviceName: string;
   static readonly WalletBalance: LightningWalletBalance;
@@ -566,6 +575,7 @@ export class Lightning {
   static readonly RestoreChannelBackups: LightningRestoreChannelBackups;
   static readonly SubscribeChannelBackups: LightningSubscribeChannelBackups;
   static readonly BakeMacaroon: LightningBakeMacaroon;
+  static readonly ListPermissions: LightningListPermissions;
 }
 
 export type ServiceError = { message: string, code: number; metadata: grpc.Metadata }
@@ -1016,5 +1026,14 @@ export class LightningClient {
     requestMessage: lnd_pb.BakeMacaroonRequest,
     callback: (error: ServiceError|null, responseMessage: lnd_pb.BakeMacaroonResponse|null) => void
   ): UnaryResponse;
+  listPermissions(
+    requestMessage: lnd_pb.ListPermissionsRequest,
+    metadata: grpc.Metadata,
+    callback: (error: ServiceError|null, responseMessage: lnd_pb.ListPermissionsResponse|null) => void
+  ): UnaryResponse;
+  listPermissions(
+    requestMessage: lnd_pb.ListPermissionsRequest,
+    callback: (error: ServiceError|null, responseMessage: lnd_pb.ListPermissionsResponse|null) => void
+  ): UnaryResponse;
 }
 

app/src/types/generated/lnd_pb_service.js

@@ -514,6 +514,15 @@ Lightning.BakeMacaroon = {
   responseType: lnd_pb.BakeMacaroonResponse
 };
 
+Lightning.ListPermissions = {
+  methodName: "ListPermissions",
+  service: Lightning,
+  requestStream: false,
+  responseStream: false,
+  requestType: lnd_pb.ListPermissionsRequest,
+  responseType: lnd_pb.ListPermissionsResponse
+};
+
 exports.Lightning = Lightning;
 
 function LightningClient(serviceHost, options) {
@@ -2363,5 +2372,36 @@ LightningClient.prototype.bakeMacaroon = function bakeMacaroon(requestMessage, m
   };
 };
 
+LightningClient.prototype.listPermissions = function listPermissions(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Lightning.ListPermissions, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
 exports.LightningClient = LightningClient;
 

app/src/types/generated/loop_pb.d.ts

@@ -644,6 +644,12 @@ export class LiquidityParameters extends jspb.Message {
   getAutoMaxInFlight(): number;
   setAutoMaxInFlight(value: number): void;
 
+  getMinSwapAmount(): number;
+  setMinSwapAmount(value: number): void;
+
+  getMaxSwapAmount(): number;
+  setMaxSwapAmount(value: number): void;
+
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): LiquidityParameters.AsObject;
   static toObject(includeInstance: boolean, msg: LiquidityParameters): LiquidityParameters.AsObject;
@@ -669,6 +675,8 @@ export namespace LiquidityParameters {
     autoOutBudgetSat: number,
     autoOutBudgetStartSec: number,
     autoMaxInFlight: number,
+    minSwapAmount: number,
+    maxSwapAmount: number,
   }
 }
 

app/src/types/generated/loop_pb.js

@@ -4400,7 +4400,9 @@ proto.looprpc.LiquidityParameters.toObject = function(includeInstance, msg) {
     autoLoopOut: jspb.Message.getFieldWithDefault(msg, 10, false),
     autoOutBudgetSat: jspb.Message.getFieldWithDefault(msg, 11, 0),
     autoOutBudgetStartSec: jspb.Message.getFieldWithDefault(msg, 12, 0),
-    autoMaxInFlight: jspb.Message.getFieldWithDefault(msg, 13, 0)
+    autoMaxInFlight: jspb.Message.getFieldWithDefault(msg, 13, 0),
+    minSwapAmount: jspb.Message.getFieldWithDefault(msg, 14, 0),
+    maxSwapAmount: jspb.Message.getFieldWithDefault(msg, 15, 0)
   };
 
   if (includeInstance) {
@@ -4490,6 +4492,14 @@ proto.looprpc.LiquidityParameters.deserializeBinaryFromReader = function(msg, re
       var value = /** @type {number} */ (reader.readUint64());
       msg.setAutoMaxInFlight(value);
       break;
+    case 14:
+      var value = /** @type {number} */ (reader.readUint64());
+      msg.setMinSwapAmount(value);
+      break;
+    case 15:
+      var value = /** @type {number} */ (reader.readUint64());
+      msg.setMaxSwapAmount(value);
+      break;
     default:
       reader.skipField();
       break;
@@ -4611,6 +4621,20 @@ proto.looprpc.LiquidityParameters.serializeBinaryToWriter = function(message, wr
       f
     );
   }
+  f = message.getMinSwapAmount();
+  if (f !== 0) {
+    writer.writeUint64(
+      14,
+      f
+    );
+  }
+  f = message.getMaxSwapAmount();
+  if (f !== 0) {
+    writer.writeUint64(
+      15,
+      f
+    );
+  }
 };
 
 
@@ -4827,6 +4851,36 @@ proto.looprpc.LiquidityParameters.prototype.setAutoMaxInFlight = function(value)
 };
 
 
+/**
+ * optional uint64 min_swap_amount = 14;
+ * @return {number}
+ */
+proto.looprpc.LiquidityParameters.prototype.getMinSwapAmount = function() {
+  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 14, 0));
+};
+
+
+/** @param {number} value */
+proto.looprpc.LiquidityParameters.prototype.setMinSwapAmount = function(value) {
+  jspb.Message.setField(this, 14, value);
+};
+
+
+/**
+ * optional uint64 max_swap_amount = 15;
+ * @return {number}
+ */
+proto.looprpc.LiquidityParameters.prototype.getMaxSwapAmount = function() {
+  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 15, 0));
+};
+
+
+/** @param {number} value */
+proto.looprpc.LiquidityParameters.prototype.setMaxSwapAmount = function(value) {
+  jspb.Message.setField(this, 15, value);
+};
+
+
 
 /**
  * Generated by JsPbCodeGenerator.

proto/lnd.proto

@@ -235,8 +235,10 @@ service Lightning {
     /* lncli: `abandonchannel`
     AbandonChannel removes all channel state from the database except for a
     close summary. This method can be used to get rid of permanently unusable
-    channels due to bugs fixed in newer versions of lnd. Only available
-    when in debug builds of lnd.
+    channels due to bugs fixed in newer versions of lnd. This method can also be
+    used to remove externally funded channels where the funding transaction was
+    never broadcast. Only available for non-externally funded channels in dev
+    build.
     */
     rpc AbandonChannel (AbandonChannelRequest) returns (AbandonChannelResponse);
 
@@ -491,6 +493,13 @@ service Lightning {
     offline.
     */
     rpc BakeMacaroon (BakeMacaroonRequest) returns (BakeMacaroonResponse);
+
+    /* lncli: `listpermissions`
+    ListPermissions lists all RPC method URIs and their required macaroon
+    permissions to access them.
+    */
+    rpc ListPermissions (ListPermissionsRequest)
+        returns (ListPermissionsResponse);
 }
 
 message Utxo {
@@ -1672,6 +1681,12 @@ message OpenChannelRequest {
     the channel. It only applies to the remote party.
     */
     uint64 remote_max_value_in_flight_msat = 15;
+
+    /*
+    The maximum number of concurrent HTLCs we will allow the remote party to add
+    to the commitment transaction.
+    */
+    uint32 remote_max_htlcs = 16;
 }
 message OpenStatusUpdate {
     oneof update {
@@ -1817,12 +1832,19 @@ message FundingPsbtFinalize {
     /*
     The funded PSBT that contains all witness data to send the exact channel
     capacity amount to the PK script returned in the open channel message in a
-    previous step.
+    previous step. Cannot be set at the same time as final_raw_tx.
     */
     bytes signed_psbt = 1;
 
     // The pending channel ID of the channel to get the PSBT for.
     bytes pending_chan_id = 2;
+
+    /*
+    As an alternative to the signed PSBT with all witness data, the final raw
+    wire format transaction can also be specified directly. Cannot be set at the
+    same time as signed_psbt.
+    */
+    bytes final_raw_tx = 3;
 }
 
 message FundingTransitionMsg {
@@ -3039,6 +3061,8 @@ message DeleteAllPaymentsResponse {
 
 message AbandonChannelRequest {
     ChannelPoint channel_point = 1;
+
+    bool pending_funding_shim_only = 2;
 }
 
 message AbandonChannelResponse {
@@ -3333,6 +3357,21 @@ message BakeMacaroonResponse {
     string macaroon = 1;
 }
 
+message MacaroonPermissionList {
+    // A list of macaroon permissions.
+    repeated MacaroonPermission permissions = 1;
+}
+
+message ListPermissionsRequest {
+}
+message ListPermissionsResponse {
+    /*
+    A map between all RPC method URIs and their required macaroon permissions to
+    access them.
+    */
+    map<string, MacaroonPermissionList> method_permissions = 1;
+}
+
 message Failure {
     enum FailureCode {
         /*
@@ -3495,3 +3534,14 @@ message ChannelUpdate {
     */
     bytes extra_opaque_data = 12;
 }
+
+message MacaroonId {
+    bytes nonce = 1;
+    bytes storageId = 2;
+    repeated Op ops = 3;
+}
+
+message Op {
+    string entity = 1;
+    repeated string actions = 2;
+}

proto/loop.proto

@@ -808,6 +808,20 @@ message LiquidityParameters {
     flight at any point in time.
     */
     uint64 auto_max_in_flight = 13;
+
+    /*
+    The minimum amount, expressed in satoshis, that the autoloop client will
+    dispatch a swap for. This value is subject to the server-side limits
+    specified by the LoopOutTerms endpoint.
+    */
+    uint64 min_swap_amount = 14;
+
+    /*
+    The maximum amount, expressed in satoshis, that the autoloop client will
+    dispatch a swap for. This value is subject to the server-side limits
+    specified by the LoopOutTerms endpoint.
+    */
+    uint64 max_swap_amount = 15;
 }
 
 enum LiquidityRuleType {