diff --git a/app/src/types/generated/loop_pb.d.ts b/app/src/types/generated/loop_pb.d.ts index 313b7c64d..2aae2b2a9 100644 --- a/app/src/types/generated/loop_pb.d.ts +++ b/app/src/types/generated/loop_pb.d.ts @@ -55,6 +55,9 @@ export class LoopOutRequest extends jspb.Message { getAccountAddrType(): AddressTypeMap[keyof AddressTypeMap]; setAccountAddrType(value: AddressTypeMap[keyof AddressTypeMap]): void; + getIsExternalAddr(): boolean; + setIsExternalAddr(value: boolean): void; + serializeBinary(): Uint8Array; toObject(includeInstance?: boolean): LoopOutRequest.AsObject; static toObject(includeInstance: boolean, msg: LoopOutRequest): LoopOutRequest.AsObject; @@ -83,6 +86,7 @@ export namespace LoopOutRequest { initiator: string, account: string, accountAddrType: AddressTypeMap[keyof AddressTypeMap], + isExternalAddr: boolean, } } @@ -295,6 +299,11 @@ export namespace SwapStatus { } export class ListSwapsRequest extends jspb.Message { + hasListSwapFilter(): boolean; + clearListSwapFilter(): void; + getListSwapFilter(): ListSwapsFilter | undefined; + setListSwapFilter(value?: ListSwapsFilter): void; + serializeBinary(): Uint8Array; toObject(includeInstance?: boolean): ListSwapsRequest.AsObject; static toObject(includeInstance: boolean, msg: ListSwapsRequest): ListSwapsRequest.AsObject; @@ -307,9 +316,58 @@ export class ListSwapsRequest extends jspb.Message { export namespace ListSwapsRequest { export type AsObject = { + listSwapFilter?: ListSwapsFilter.AsObject, } } +export class ListSwapsFilter extends jspb.Message { + getSwapType(): ListSwapsFilter.SwapTypeFilterMap[keyof ListSwapsFilter.SwapTypeFilterMap]; + setSwapType(value: ListSwapsFilter.SwapTypeFilterMap[keyof ListSwapsFilter.SwapTypeFilterMap]): void; + + getPendingOnly(): boolean; + setPendingOnly(value: boolean): void; + + clearOutgoingChanSetList(): void; + getOutgoingChanSetList(): Array; + setOutgoingChanSetList(value: Array): void; + addOutgoingChanSet(value: string, index?: number): string; + + getLabel(): string; + setLabel(value: string): void; + + getLoopInLastHop(): Uint8Array | string; + getLoopInLastHop_asU8(): Uint8Array; + getLoopInLastHop_asB64(): string; + setLoopInLastHop(value: Uint8Array | string): void; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): ListSwapsFilter.AsObject; + static toObject(includeInstance: boolean, msg: ListSwapsFilter): ListSwapsFilter.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: ListSwapsFilter, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): ListSwapsFilter; + static deserializeBinaryFromReader(message: ListSwapsFilter, reader: jspb.BinaryReader): ListSwapsFilter; +} + +export namespace ListSwapsFilter { + export type AsObject = { + swapType: ListSwapsFilter.SwapTypeFilterMap[keyof ListSwapsFilter.SwapTypeFilterMap], + pendingOnly: boolean, + outgoingChanSetList: Array, + label: string, + loopInLastHop: Uint8Array | string, + } + + export interface SwapTypeFilterMap { + ANY: 0; + LOOP_OUT: 1; + LOOP_IN: 2; + } + + export const SwapTypeFilter: SwapTypeFilterMap; +} + export class ListSwapsResponse extends jspb.Message { clearSwapsList(): void; getSwapsList(): Array; @@ -1128,6 +1186,88 @@ export namespace AbandonSwapResponse { } } +export class ListReservationsRequest extends jspb.Message { + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): ListReservationsRequest.AsObject; + static toObject(includeInstance: boolean, msg: ListReservationsRequest): ListReservationsRequest.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: ListReservationsRequest, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): ListReservationsRequest; + static deserializeBinaryFromReader(message: ListReservationsRequest, reader: jspb.BinaryReader): ListReservationsRequest; +} + +export namespace ListReservationsRequest { + export type AsObject = { + } +} + +export class ListReservationsResponse extends jspb.Message { + clearReservationsList(): void; + getReservationsList(): Array; + setReservationsList(value: Array): void; + addReservations(value?: ClientReservation, index?: number): ClientReservation; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): ListReservationsResponse.AsObject; + static toObject(includeInstance: boolean, msg: ListReservationsResponse): ListReservationsResponse.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: ListReservationsResponse, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): ListReservationsResponse; + static deserializeBinaryFromReader(message: ListReservationsResponse, reader: jspb.BinaryReader): ListReservationsResponse; +} + +export namespace ListReservationsResponse { + export type AsObject = { + reservationsList: Array, + } +} + +export class ClientReservation extends jspb.Message { + getReservationId(): Uint8Array | string; + getReservationId_asU8(): Uint8Array; + getReservationId_asB64(): string; + setReservationId(value: Uint8Array | string): void; + + getState(): string; + setState(value: string): void; + + getAmount(): string; + setAmount(value: string): void; + + getTxId(): Uint8Array | string; + getTxId_asU8(): Uint8Array; + getTxId_asB64(): string; + setTxId(value: Uint8Array | string): void; + + getVout(): number; + setVout(value: number): void; + + getExpiry(): number; + setExpiry(value: number): void; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): ClientReservation.AsObject; + static toObject(includeInstance: boolean, msg: ClientReservation): ClientReservation.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: ClientReservation, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): ClientReservation; + static deserializeBinaryFromReader(message: ClientReservation, reader: jspb.BinaryReader): ClientReservation; +} + +export namespace ClientReservation { + export type AsObject = { + reservationId: Uint8Array | string, + state: string, + amount: string, + txId: Uint8Array | string, + vout: number, + expiry: number, + } +} + export interface AddressTypeMap { ADDRESS_TYPE_UNKNOWN: 0; TAPROOT_PUBKEY: 1; diff --git a/app/src/types/generated/loop_pb.js b/app/src/types/generated/loop_pb.js index cfaf01a7d..11c6977a4 100644 --- a/app/src/types/generated/loop_pb.js +++ b/app/src/types/generated/loop_pb.js @@ -19,6 +19,7 @@ goog.exportSymbol('proto.looprpc.AbandonSwapRequest', null, global); goog.exportSymbol('proto.looprpc.AbandonSwapResponse', null, global); goog.exportSymbol('proto.looprpc.AddressType', null, global); goog.exportSymbol('proto.looprpc.AutoReason', null, global); +goog.exportSymbol('proto.looprpc.ClientReservation', null, global); goog.exportSymbol('proto.looprpc.Disqualified', null, global); goog.exportSymbol('proto.looprpc.FailureReason', null, global); goog.exportSymbol('proto.looprpc.GetInfoRequest', null, global); @@ -29,6 +30,10 @@ goog.exportSymbol('proto.looprpc.InTermsResponse', null, global); goog.exportSymbol('proto.looprpc.LiquidityParameters', null, global); goog.exportSymbol('proto.looprpc.LiquidityRule', null, global); goog.exportSymbol('proto.looprpc.LiquidityRuleType', null, global); +goog.exportSymbol('proto.looprpc.ListReservationsRequest', null, global); +goog.exportSymbol('proto.looprpc.ListReservationsResponse', null, global); +goog.exportSymbol('proto.looprpc.ListSwapsFilter', null, global); +goog.exportSymbol('proto.looprpc.ListSwapsFilter.SwapTypeFilter', null, global); goog.exportSymbol('proto.looprpc.ListSwapsRequest', null, global); goog.exportSymbol('proto.looprpc.ListSwapsResponse', null, global); goog.exportSymbol('proto.looprpc.LoopInRequest', null, global); @@ -122,7 +127,8 @@ proto.looprpc.LoopOutRequest.toObject = function(includeInstance, msg) { label: jspb.Message.getFieldWithDefault(msg, 12, ""), initiator: jspb.Message.getFieldWithDefault(msg, 14, ""), account: jspb.Message.getFieldWithDefault(msg, 15, ""), - accountAddrType: jspb.Message.getFieldWithDefault(msg, 16, 0) + accountAddrType: jspb.Message.getFieldWithDefault(msg, 16, 0), + isExternalAddr: jspb.Message.getFieldWithDefault(msg, 17, false) }; if (includeInstance) { @@ -223,6 +229,10 @@ proto.looprpc.LoopOutRequest.deserializeBinaryFromReader = function(msg, reader) var value = /** @type {!proto.looprpc.AddressType} */ (reader.readEnum()); msg.setAccountAddrType(value); break; + case 17: + var value = /** @type {boolean} */ (reader.readBool()); + msg.setIsExternalAddr(value); + break; default: reader.skipField(); break; @@ -364,6 +374,13 @@ proto.looprpc.LoopOutRequest.serializeBinaryToWriter = function(message, writer) f ); } + f = message.getIsExternalAddr(); + if (f) { + writer.writeBool( + 17, + f + ); + } }; @@ -621,6 +638,23 @@ proto.looprpc.LoopOutRequest.prototype.setAccountAddrType = function(value) { }; +/** + * optional bool is_external_addr = 17; + * Note that Boolean fields may be set to 0/1 when serialized from a Java server. + * You should avoid comparisons like {@code val === true/false} in those cases. + * @return {boolean} + */ +proto.looprpc.LoopOutRequest.prototype.getIsExternalAddr = function() { + return /** @type {boolean} */ (jspb.Message.getFieldWithDefault(this, 17, false)); +}; + + +/** @param {boolean} value */ +proto.looprpc.LoopOutRequest.prototype.setIsExternalAddr = function(value) { + jspb.Message.setProto3BooleanField(this, 17, value); +}; + + /** * Generated by JsPbCodeGenerator. @@ -2167,7 +2201,7 @@ proto.looprpc.ListSwapsRequest.prototype.toObject = function(opt_includeInstance */ proto.looprpc.ListSwapsRequest.toObject = function(includeInstance, msg) { var f, obj = { - + listSwapFilter: (f = msg.getListSwapFilter()) && proto.looprpc.ListSwapsFilter.toObject(includeInstance, f) }; if (includeInstance) { @@ -2204,6 +2238,11 @@ proto.looprpc.ListSwapsRequest.deserializeBinaryFromReader = function(msg, reade } var field = reader.getFieldNumber(); switch (field) { + case 1: + var value = new proto.looprpc.ListSwapsFilter; + reader.readMessage(value,proto.looprpc.ListSwapsFilter.deserializeBinaryFromReader); + msg.setListSwapFilter(value); + break; default: reader.skipField(); break; @@ -2233,6 +2272,44 @@ proto.looprpc.ListSwapsRequest.prototype.serializeBinary = function() { */ proto.looprpc.ListSwapsRequest.serializeBinaryToWriter = function(message, writer) { var f = undefined; + f = message.getListSwapFilter(); + if (f != null) { + writer.writeMessage( + 1, + f, + proto.looprpc.ListSwapsFilter.serializeBinaryToWriter + ); + } +}; + + +/** + * optional ListSwapsFilter list_swap_filter = 1; + * @return {?proto.looprpc.ListSwapsFilter} + */ +proto.looprpc.ListSwapsRequest.prototype.getListSwapFilter = function() { + return /** @type{?proto.looprpc.ListSwapsFilter} */ ( + jspb.Message.getWrapperField(this, proto.looprpc.ListSwapsFilter, 1)); +}; + + +/** @param {?proto.looprpc.ListSwapsFilter|undefined} value */ +proto.looprpc.ListSwapsRequest.prototype.setListSwapFilter = function(value) { + jspb.Message.setWrapperField(this, 1, value); +}; + + +proto.looprpc.ListSwapsRequest.prototype.clearListSwapFilter = function() { + this.setListSwapFilter(undefined); +}; + + +/** + * Returns whether this field is set. + * @return {!boolean} + */ +proto.looprpc.ListSwapsRequest.prototype.hasListSwapFilter = function() { + return jspb.Message.getField(this, 1) != null; }; @@ -2247,19 +2324,19 @@ proto.looprpc.ListSwapsRequest.serializeBinaryToWriter = function(message, write * @extends {jspb.Message} * @constructor */ -proto.looprpc.ListSwapsResponse = function(opt_data) { - jspb.Message.initialize(this, opt_data, 0, -1, proto.looprpc.ListSwapsResponse.repeatedFields_, null); +proto.looprpc.ListSwapsFilter = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.looprpc.ListSwapsFilter.repeatedFields_, null); }; -goog.inherits(proto.looprpc.ListSwapsResponse, jspb.Message); +goog.inherits(proto.looprpc.ListSwapsFilter, jspb.Message); if (goog.DEBUG && !COMPILED) { - proto.looprpc.ListSwapsResponse.displayName = 'proto.looprpc.ListSwapsResponse'; + proto.looprpc.ListSwapsFilter.displayName = 'proto.looprpc.ListSwapsFilter'; } /** * List of repeated fields within this message type. * @private {!Array} * @const */ -proto.looprpc.ListSwapsResponse.repeatedFields_ = [1]; +proto.looprpc.ListSwapsFilter.repeatedFields_ = [3]; @@ -2274,8 +2351,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * for transitional soy proto support: http://goto/soy-param-migration * @return {!Object} */ -proto.looprpc.ListSwapsResponse.prototype.toObject = function(opt_includeInstance) { - return proto.looprpc.ListSwapsResponse.toObject(opt_includeInstance, this); +proto.looprpc.ListSwapsFilter.prototype.toObject = function(opt_includeInstance) { + return proto.looprpc.ListSwapsFilter.toObject(opt_includeInstance, this); }; @@ -2284,14 +2361,17 @@ proto.looprpc.ListSwapsResponse.prototype.toObject = function(opt_includeInstanc * @param {boolean|undefined} includeInstance Whether to include the JSPB * instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.looprpc.ListSwapsResponse} msg The msg instance to transform. + * @param {!proto.looprpc.ListSwapsFilter} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.looprpc.ListSwapsResponse.toObject = function(includeInstance, msg) { +proto.looprpc.ListSwapsFilter.toObject = function(includeInstance, msg) { var f, obj = { - swapsList: jspb.Message.toObjectList(msg.getSwapsList(), - proto.looprpc.SwapStatus.toObject, includeInstance) + swapType: jspb.Message.getFieldWithDefault(msg, 1, 0), + pendingOnly: jspb.Message.getFieldWithDefault(msg, 2, false), + outgoingChanSetList: jspb.Message.getRepeatedField(msg, 3), + label: jspb.Message.getFieldWithDefault(msg, 4, ""), + loopInLastHop: msg.getLoopInLastHop_asB64() }; if (includeInstance) { @@ -2305,23 +2385,23 @@ proto.looprpc.ListSwapsResponse.toObject = function(includeInstance, msg) { /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.looprpc.ListSwapsResponse} + * @return {!proto.looprpc.ListSwapsFilter} */ -proto.looprpc.ListSwapsResponse.deserializeBinary = function(bytes) { +proto.looprpc.ListSwapsFilter.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.looprpc.ListSwapsResponse; - return proto.looprpc.ListSwapsResponse.deserializeBinaryFromReader(msg, reader); + var msg = new proto.looprpc.ListSwapsFilter; + return proto.looprpc.ListSwapsFilter.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.looprpc.ListSwapsResponse} msg The message object to deserialize into. + * @param {!proto.looprpc.ListSwapsFilter} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.looprpc.ListSwapsResponse} + * @return {!proto.looprpc.ListSwapsFilter} */ -proto.looprpc.ListSwapsResponse.deserializeBinaryFromReader = function(msg, reader) { +proto.looprpc.ListSwapsFilter.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { if (reader.isEndGroup()) { break; @@ -2329,9 +2409,24 @@ proto.looprpc.ListSwapsResponse.deserializeBinaryFromReader = function(msg, read var field = reader.getFieldNumber(); switch (field) { case 1: - var value = new proto.looprpc.SwapStatus; - reader.readMessage(value,proto.looprpc.SwapStatus.deserializeBinaryFromReader); - msg.addSwaps(value); + var value = /** @type {!proto.looprpc.ListSwapsFilter.SwapTypeFilter} */ (reader.readEnum()); + msg.setSwapType(value); + break; + case 2: + var value = /** @type {boolean} */ (reader.readBool()); + msg.setPendingOnly(value); + break; + case 3: + var value = /** @type {!Array} */ (reader.readPackedUint64String()); + msg.setOutgoingChanSetList(value); + break; + case 4: + var value = /** @type {string} */ (reader.readString()); + msg.setLabel(value); + break; + case 5: + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setLoopInLastHop(value); break; default: reader.skipField(); @@ -2346,9 +2441,9 @@ proto.looprpc.ListSwapsResponse.deserializeBinaryFromReader = function(msg, read * Serializes the message to binary data (in protobuf wire format). * @return {!Uint8Array} */ -proto.looprpc.ListSwapsResponse.prototype.serializeBinary = function() { +proto.looprpc.ListSwapsFilter.prototype.serializeBinary = function() { var writer = new jspb.BinaryWriter(); - proto.looprpc.ListSwapsResponse.serializeBinaryToWriter(this, writer); + proto.looprpc.ListSwapsFilter.serializeBinaryToWriter(this, writer); return writer.getResultBuffer(); }; @@ -2356,51 +2451,171 @@ proto.looprpc.ListSwapsResponse.prototype.serializeBinary = function() { /** * Serializes the given message to binary data (in protobuf wire * format), writing to the given BinaryWriter. - * @param {!proto.looprpc.ListSwapsResponse} message + * @param {!proto.looprpc.ListSwapsFilter} message * @param {!jspb.BinaryWriter} writer * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.looprpc.ListSwapsResponse.serializeBinaryToWriter = function(message, writer) { +proto.looprpc.ListSwapsFilter.serializeBinaryToWriter = function(message, writer) { var f = undefined; - f = message.getSwapsList(); - if (f.length > 0) { - writer.writeRepeatedMessage( + f = message.getSwapType(); + if (f !== 0.0) { + writer.writeEnum( 1, - f, - proto.looprpc.SwapStatus.serializeBinaryToWriter + f + ); + } + f = message.getPendingOnly(); + if (f) { + writer.writeBool( + 2, + f + ); + } + f = message.getOutgoingChanSetList(); + if (f.length > 0) { + writer.writePackedUint64String( + 3, + f + ); + } + f = message.getLabel(); + if (f.length > 0) { + writer.writeString( + 4, + f + ); + } + f = message.getLoopInLastHop_asU8(); + if (f.length > 0) { + writer.writeBytes( + 5, + f ); } }; /** - * repeated SwapStatus swaps = 1; - * @return {!Array} + * @enum {number} */ -proto.looprpc.ListSwapsResponse.prototype.getSwapsList = function() { - return /** @type{!Array} */ ( - jspb.Message.getRepeatedWrapperField(this, proto.looprpc.SwapStatus, 1)); +proto.looprpc.ListSwapsFilter.SwapTypeFilter = { + ANY: 0, + LOOP_OUT: 1, + LOOP_IN: 2 +}; + +/** + * optional SwapTypeFilter swap_type = 1; + * @return {!proto.looprpc.ListSwapsFilter.SwapTypeFilter} + */ +proto.looprpc.ListSwapsFilter.prototype.getSwapType = function() { + return /** @type {!proto.looprpc.ListSwapsFilter.SwapTypeFilter} */ (jspb.Message.getFieldWithDefault(this, 1, 0)); }; -/** @param {!Array} value */ -proto.looprpc.ListSwapsResponse.prototype.setSwapsList = function(value) { - jspb.Message.setRepeatedWrapperField(this, 1, value); +/** @param {!proto.looprpc.ListSwapsFilter.SwapTypeFilter} value */ +proto.looprpc.ListSwapsFilter.prototype.setSwapType = function(value) { + jspb.Message.setProto3EnumField(this, 1, value); }; /** - * @param {!proto.looprpc.SwapStatus=} opt_value + * optional bool pending_only = 2; + * Note that Boolean fields may be set to 0/1 when serialized from a Java server. + * You should avoid comparisons like {@code val === true/false} in those cases. + * @return {boolean} + */ +proto.looprpc.ListSwapsFilter.prototype.getPendingOnly = function() { + return /** @type {boolean} */ (jspb.Message.getFieldWithDefault(this, 2, false)); +}; + + +/** @param {boolean} value */ +proto.looprpc.ListSwapsFilter.prototype.setPendingOnly = function(value) { + jspb.Message.setProto3BooleanField(this, 2, value); +}; + + +/** + * repeated uint64 outgoing_chan_set = 3; + * @return {!Array} + */ +proto.looprpc.ListSwapsFilter.prototype.getOutgoingChanSetList = function() { + return /** @type {!Array} */ (jspb.Message.getRepeatedField(this, 3)); +}; + + +/** @param {!Array} value */ +proto.looprpc.ListSwapsFilter.prototype.setOutgoingChanSetList = function(value) { + jspb.Message.setField(this, 3, value || []); +}; + + +/** + * @param {!string} value * @param {number=} opt_index - * @return {!proto.looprpc.SwapStatus} */ -proto.looprpc.ListSwapsResponse.prototype.addSwaps = function(opt_value, opt_index) { - return jspb.Message.addToRepeatedWrapperField(this, 1, opt_value, proto.looprpc.SwapStatus, opt_index); +proto.looprpc.ListSwapsFilter.prototype.addOutgoingChanSet = function(value, opt_index) { + jspb.Message.addToRepeatedField(this, 3, value, opt_index); }; -proto.looprpc.ListSwapsResponse.prototype.clearSwapsList = function() { - this.setSwapsList([]); +proto.looprpc.ListSwapsFilter.prototype.clearOutgoingChanSetList = function() { + this.setOutgoingChanSetList([]); +}; + + +/** + * optional string label = 4; + * @return {string} + */ +proto.looprpc.ListSwapsFilter.prototype.getLabel = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, "")); +}; + + +/** @param {string} value */ +proto.looprpc.ListSwapsFilter.prototype.setLabel = function(value) { + jspb.Message.setProto3StringField(this, 4, value); +}; + + +/** + * optional bytes loop_in_last_hop = 5; + * @return {!(string|Uint8Array)} + */ +proto.looprpc.ListSwapsFilter.prototype.getLoopInLastHop = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 5, "")); +}; + + +/** + * optional bytes loop_in_last_hop = 5; + * This is a type-conversion wrapper around `getLoopInLastHop()` + * @return {string} + */ +proto.looprpc.ListSwapsFilter.prototype.getLoopInLastHop_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getLoopInLastHop())); +}; + + +/** + * optional bytes loop_in_last_hop = 5; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getLoopInLastHop()` + * @return {!Uint8Array} + */ +proto.looprpc.ListSwapsFilter.prototype.getLoopInLastHop_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getLoopInLastHop())); +}; + + +/** @param {!(string|Uint8Array)} value */ +proto.looprpc.ListSwapsFilter.prototype.setLoopInLastHop = function(value) { + jspb.Message.setProto3BytesField(this, 5, value); }; @@ -2415,13 +2630,20 @@ proto.looprpc.ListSwapsResponse.prototype.clearSwapsList = function() { * @extends {jspb.Message} * @constructor */ -proto.looprpc.SwapInfoRequest = function(opt_data) { - jspb.Message.initialize(this, opt_data, 0, -1, null, null); +proto.looprpc.ListSwapsResponse = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.looprpc.ListSwapsResponse.repeatedFields_, null); }; -goog.inherits(proto.looprpc.SwapInfoRequest, jspb.Message); +goog.inherits(proto.looprpc.ListSwapsResponse, jspb.Message); if (goog.DEBUG && !COMPILED) { - proto.looprpc.SwapInfoRequest.displayName = 'proto.looprpc.SwapInfoRequest'; + proto.looprpc.ListSwapsResponse.displayName = 'proto.looprpc.ListSwapsResponse'; } +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.looprpc.ListSwapsResponse.repeatedFields_ = [1]; + if (jspb.Message.GENERATE_TO_OBJECT) { @@ -2435,8 +2657,8 @@ if (jspb.Message.GENERATE_TO_OBJECT) { * for transitional soy proto support: http://goto/soy-param-migration * @return {!Object} */ -proto.looprpc.SwapInfoRequest.prototype.toObject = function(opt_includeInstance) { - return proto.looprpc.SwapInfoRequest.toObject(opt_includeInstance, this); +proto.looprpc.ListSwapsResponse.prototype.toObject = function(opt_includeInstance) { + return proto.looprpc.ListSwapsResponse.toObject(opt_includeInstance, this); }; @@ -2445,13 +2667,14 @@ proto.looprpc.SwapInfoRequest.prototype.toObject = function(opt_includeInstance) * @param {boolean|undefined} includeInstance Whether to include the JSPB * instance for transitional soy proto support: * http://goto/soy-param-migration - * @param {!proto.looprpc.SwapInfoRequest} msg The msg instance to transform. + * @param {!proto.looprpc.ListSwapsResponse} msg The msg instance to transform. * @return {!Object} * @suppress {unusedLocalVariables} f is only used for nested messages */ -proto.looprpc.SwapInfoRequest.toObject = function(includeInstance, msg) { +proto.looprpc.ListSwapsResponse.toObject = function(includeInstance, msg) { var f, obj = { - id: msg.getId_asB64() + swapsList: jspb.Message.toObjectList(msg.getSwapsList(), + proto.looprpc.SwapStatus.toObject, includeInstance) }; if (includeInstance) { @@ -2465,21 +2688,181 @@ proto.looprpc.SwapInfoRequest.toObject = function(includeInstance, msg) { /** * Deserializes binary data (in protobuf wire format). * @param {jspb.ByteSource} bytes The bytes to deserialize. - * @return {!proto.looprpc.SwapInfoRequest} + * @return {!proto.looprpc.ListSwapsResponse} */ -proto.looprpc.SwapInfoRequest.deserializeBinary = function(bytes) { +proto.looprpc.ListSwapsResponse.deserializeBinary = function(bytes) { var reader = new jspb.BinaryReader(bytes); - var msg = new proto.looprpc.SwapInfoRequest; - return proto.looprpc.SwapInfoRequest.deserializeBinaryFromReader(msg, reader); + var msg = new proto.looprpc.ListSwapsResponse; + return proto.looprpc.ListSwapsResponse.deserializeBinaryFromReader(msg, reader); }; /** * Deserializes binary data (in protobuf wire format) from the * given reader into the given message object. - * @param {!proto.looprpc.SwapInfoRequest} msg The message object to deserialize into. + * @param {!proto.looprpc.ListSwapsResponse} msg The message object to deserialize into. * @param {!jspb.BinaryReader} reader The BinaryReader to use. - * @return {!proto.looprpc.SwapInfoRequest} + * @return {!proto.looprpc.ListSwapsResponse} + */ +proto.looprpc.ListSwapsResponse.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = new proto.looprpc.SwapStatus; + reader.readMessage(value,proto.looprpc.SwapStatus.deserializeBinaryFromReader); + msg.addSwaps(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.looprpc.ListSwapsResponse.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.looprpc.ListSwapsResponse.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.looprpc.ListSwapsResponse} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.looprpc.ListSwapsResponse.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getSwapsList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 1, + f, + proto.looprpc.SwapStatus.serializeBinaryToWriter + ); + } +}; + + +/** + * repeated SwapStatus swaps = 1; + * @return {!Array} + */ +proto.looprpc.ListSwapsResponse.prototype.getSwapsList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.looprpc.SwapStatus, 1)); +}; + + +/** @param {!Array} value */ +proto.looprpc.ListSwapsResponse.prototype.setSwapsList = function(value) { + jspb.Message.setRepeatedWrapperField(this, 1, value); +}; + + +/** + * @param {!proto.looprpc.SwapStatus=} opt_value + * @param {number=} opt_index + * @return {!proto.looprpc.SwapStatus} + */ +proto.looprpc.ListSwapsResponse.prototype.addSwaps = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 1, opt_value, proto.looprpc.SwapStatus, opt_index); +}; + + +proto.looprpc.ListSwapsResponse.prototype.clearSwapsList = function() { + this.setSwapsList([]); +}; + + + +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.looprpc.SwapInfoRequest = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.looprpc.SwapInfoRequest, jspb.Message); +if (goog.DEBUG && !COMPILED) { + proto.looprpc.SwapInfoRequest.displayName = 'proto.looprpc.SwapInfoRequest'; +} + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto suitable for use in Soy templates. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * com.google.apps.jspb.JsClassTemplate.JS_RESERVED_WORDS. + * @param {boolean=} opt_includeInstance Whether to include the JSPB instance + * for transitional soy proto support: http://goto/soy-param-migration + * @return {!Object} + */ +proto.looprpc.SwapInfoRequest.prototype.toObject = function(opt_includeInstance) { + return proto.looprpc.SwapInfoRequest.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Whether to include the JSPB + * instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.looprpc.SwapInfoRequest} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.looprpc.SwapInfoRequest.toObject = function(includeInstance, msg) { + var f, obj = { + id: msg.getId_asB64() + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.looprpc.SwapInfoRequest} + */ +proto.looprpc.SwapInfoRequest.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.looprpc.SwapInfoRequest; + return proto.looprpc.SwapInfoRequest.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.looprpc.SwapInfoRequest} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.looprpc.SwapInfoRequest} */ proto.looprpc.SwapInfoRequest.deserializeBinaryFromReader = function(msg, reader) { while (reader.nextField()) { @@ -8161,6 +8544,615 @@ proto.looprpc.AbandonSwapResponse.serializeBinaryToWriter = function(message, wr }; + +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.looprpc.ListReservationsRequest = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.looprpc.ListReservationsRequest, jspb.Message); +if (goog.DEBUG && !COMPILED) { + proto.looprpc.ListReservationsRequest.displayName = 'proto.looprpc.ListReservationsRequest'; +} + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto suitable for use in Soy templates. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * com.google.apps.jspb.JsClassTemplate.JS_RESERVED_WORDS. + * @param {boolean=} opt_includeInstance Whether to include the JSPB instance + * for transitional soy proto support: http://goto/soy-param-migration + * @return {!Object} + */ +proto.looprpc.ListReservationsRequest.prototype.toObject = function(opt_includeInstance) { + return proto.looprpc.ListReservationsRequest.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Whether to include the JSPB + * instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.looprpc.ListReservationsRequest} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.looprpc.ListReservationsRequest.toObject = function(includeInstance, msg) { + var f, obj = { + + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.looprpc.ListReservationsRequest} + */ +proto.looprpc.ListReservationsRequest.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.looprpc.ListReservationsRequest; + return proto.looprpc.ListReservationsRequest.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.looprpc.ListReservationsRequest} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.looprpc.ListReservationsRequest} + */ +proto.looprpc.ListReservationsRequest.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.looprpc.ListReservationsRequest.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.looprpc.ListReservationsRequest.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.looprpc.ListReservationsRequest} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.looprpc.ListReservationsRequest.serializeBinaryToWriter = function(message, writer) { + var f = undefined; +}; + + + +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.looprpc.ListReservationsResponse = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.looprpc.ListReservationsResponse.repeatedFields_, null); +}; +goog.inherits(proto.looprpc.ListReservationsResponse, jspb.Message); +if (goog.DEBUG && !COMPILED) { + proto.looprpc.ListReservationsResponse.displayName = 'proto.looprpc.ListReservationsResponse'; +} +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.looprpc.ListReservationsResponse.repeatedFields_ = [1]; + + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto suitable for use in Soy templates. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * com.google.apps.jspb.JsClassTemplate.JS_RESERVED_WORDS. + * @param {boolean=} opt_includeInstance Whether to include the JSPB instance + * for transitional soy proto support: http://goto/soy-param-migration + * @return {!Object} + */ +proto.looprpc.ListReservationsResponse.prototype.toObject = function(opt_includeInstance) { + return proto.looprpc.ListReservationsResponse.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Whether to include the JSPB + * instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.looprpc.ListReservationsResponse} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.looprpc.ListReservationsResponse.toObject = function(includeInstance, msg) { + var f, obj = { + reservationsList: jspb.Message.toObjectList(msg.getReservationsList(), + proto.looprpc.ClientReservation.toObject, includeInstance) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.looprpc.ListReservationsResponse} + */ +proto.looprpc.ListReservationsResponse.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.looprpc.ListReservationsResponse; + return proto.looprpc.ListReservationsResponse.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.looprpc.ListReservationsResponse} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.looprpc.ListReservationsResponse} + */ +proto.looprpc.ListReservationsResponse.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = new proto.looprpc.ClientReservation; + reader.readMessage(value,proto.looprpc.ClientReservation.deserializeBinaryFromReader); + msg.addReservations(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.looprpc.ListReservationsResponse.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.looprpc.ListReservationsResponse.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.looprpc.ListReservationsResponse} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.looprpc.ListReservationsResponse.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getReservationsList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 1, + f, + proto.looprpc.ClientReservation.serializeBinaryToWriter + ); + } +}; + + +/** + * repeated ClientReservation reservations = 1; + * @return {!Array} + */ +proto.looprpc.ListReservationsResponse.prototype.getReservationsList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.looprpc.ClientReservation, 1)); +}; + + +/** @param {!Array} value */ +proto.looprpc.ListReservationsResponse.prototype.setReservationsList = function(value) { + jspb.Message.setRepeatedWrapperField(this, 1, value); +}; + + +/** + * @param {!proto.looprpc.ClientReservation=} opt_value + * @param {number=} opt_index + * @return {!proto.looprpc.ClientReservation} + */ +proto.looprpc.ListReservationsResponse.prototype.addReservations = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 1, opt_value, proto.looprpc.ClientReservation, opt_index); +}; + + +proto.looprpc.ListReservationsResponse.prototype.clearReservationsList = function() { + this.setReservationsList([]); +}; + + + +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.looprpc.ClientReservation = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.looprpc.ClientReservation, jspb.Message); +if (goog.DEBUG && !COMPILED) { + proto.looprpc.ClientReservation.displayName = 'proto.looprpc.ClientReservation'; +} + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto suitable for use in Soy templates. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * com.google.apps.jspb.JsClassTemplate.JS_RESERVED_WORDS. + * @param {boolean=} opt_includeInstance Whether to include the JSPB instance + * for transitional soy proto support: http://goto/soy-param-migration + * @return {!Object} + */ +proto.looprpc.ClientReservation.prototype.toObject = function(opt_includeInstance) { + return proto.looprpc.ClientReservation.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Whether to include the JSPB + * instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.looprpc.ClientReservation} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.looprpc.ClientReservation.toObject = function(includeInstance, msg) { + var f, obj = { + reservationId: msg.getReservationId_asB64(), + state: jspb.Message.getFieldWithDefault(msg, 2, ""), + amount: jspb.Message.getFieldWithDefault(msg, 3, "0"), + txId: msg.getTxId_asB64(), + vout: jspb.Message.getFieldWithDefault(msg, 5, 0), + expiry: jspb.Message.getFieldWithDefault(msg, 6, 0) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.looprpc.ClientReservation} + */ +proto.looprpc.ClientReservation.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.looprpc.ClientReservation; + return proto.looprpc.ClientReservation.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.looprpc.ClientReservation} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.looprpc.ClientReservation} + */ +proto.looprpc.ClientReservation.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setReservationId(value); + break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setState(value); + break; + case 3: + var value = /** @type {string} */ (reader.readUint64String()); + msg.setAmount(value); + break; + case 4: + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setTxId(value); + break; + case 5: + var value = /** @type {number} */ (reader.readUint32()); + msg.setVout(value); + break; + case 6: + var value = /** @type {number} */ (reader.readUint32()); + msg.setExpiry(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.looprpc.ClientReservation.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.looprpc.ClientReservation.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.looprpc.ClientReservation} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.looprpc.ClientReservation.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getReservationId_asU8(); + if (f.length > 0) { + writer.writeBytes( + 1, + f + ); + } + f = message.getState(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } + f = message.getAmount(); + if (parseInt(f, 10) !== 0) { + writer.writeUint64String( + 3, + f + ); + } + f = message.getTxId_asU8(); + if (f.length > 0) { + writer.writeBytes( + 4, + f + ); + } + f = message.getVout(); + if (f !== 0) { + writer.writeUint32( + 5, + f + ); + } + f = message.getExpiry(); + if (f !== 0) { + writer.writeUint32( + 6, + f + ); + } +}; + + +/** + * optional bytes reservation_id = 1; + * @return {!(string|Uint8Array)} + */ +proto.looprpc.ClientReservation.prototype.getReservationId = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** + * optional bytes reservation_id = 1; + * This is a type-conversion wrapper around `getReservationId()` + * @return {string} + */ +proto.looprpc.ClientReservation.prototype.getReservationId_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getReservationId())); +}; + + +/** + * optional bytes reservation_id = 1; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getReservationId()` + * @return {!Uint8Array} + */ +proto.looprpc.ClientReservation.prototype.getReservationId_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getReservationId())); +}; + + +/** @param {!(string|Uint8Array)} value */ +proto.looprpc.ClientReservation.prototype.setReservationId = function(value) { + jspb.Message.setProto3BytesField(this, 1, value); +}; + + +/** + * optional string state = 2; + * @return {string} + */ +proto.looprpc.ClientReservation.prototype.getState = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** @param {string} value */ +proto.looprpc.ClientReservation.prototype.setState = function(value) { + jspb.Message.setProto3StringField(this, 2, value); +}; + + +/** + * optional uint64 amount = 3; + * @return {string} + */ +proto.looprpc.ClientReservation.prototype.getAmount = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, "0")); +}; + + +/** @param {string} value */ +proto.looprpc.ClientReservation.prototype.setAmount = function(value) { + jspb.Message.setProto3StringIntField(this, 3, value); +}; + + +/** + * optional bytes tx_id = 4; + * @return {!(string|Uint8Array)} + */ +proto.looprpc.ClientReservation.prototype.getTxId = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 4, "")); +}; + + +/** + * optional bytes tx_id = 4; + * This is a type-conversion wrapper around `getTxId()` + * @return {string} + */ +proto.looprpc.ClientReservation.prototype.getTxId_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getTxId())); +}; + + +/** + * optional bytes tx_id = 4; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getTxId()` + * @return {!Uint8Array} + */ +proto.looprpc.ClientReservation.prototype.getTxId_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getTxId())); +}; + + +/** @param {!(string|Uint8Array)} value */ +proto.looprpc.ClientReservation.prototype.setTxId = function(value) { + jspb.Message.setProto3BytesField(this, 4, value); +}; + + +/** + * optional uint32 vout = 5; + * @return {number} + */ +proto.looprpc.ClientReservation.prototype.getVout = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 5, 0)); +}; + + +/** @param {number} value */ +proto.looprpc.ClientReservation.prototype.setVout = function(value) { + jspb.Message.setProto3IntField(this, 5, value); +}; + + +/** + * optional uint32 expiry = 6; + * @return {number} + */ +proto.looprpc.ClientReservation.prototype.getExpiry = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 6, 0)); +}; + + +/** @param {number} value */ +proto.looprpc.ClientReservation.prototype.setExpiry = function(value) { + jspb.Message.setProto3IntField(this, 6, value); +}; + + /** * @enum {number} */ diff --git a/app/src/types/generated/loop_pb_service.d.ts b/app/src/types/generated/loop_pb_service.d.ts index 0668e1b92..5bc78a247 100644 --- a/app/src/types/generated/loop_pb_service.d.ts +++ b/app/src/types/generated/loop_pb_service.d.ts @@ -148,6 +148,15 @@ type SwapClientSuggestSwaps = { readonly responseType: typeof loop_pb.SuggestSwapsResponse; }; +type SwapClientListReservations = { + readonly methodName: string; + readonly service: typeof SwapClient; + readonly requestStream: false; + readonly responseStream: false; + readonly requestType: typeof loop_pb.ListReservationsRequest; + readonly responseType: typeof loop_pb.ListReservationsResponse; +}; + export class SwapClient { static readonly serviceName: string; static readonly LoopOut: SwapClientLoopOut; @@ -166,6 +175,7 @@ export class SwapClient { static readonly GetLiquidityParams: SwapClientGetLiquidityParams; static readonly SetLiquidityParams: SwapClientSetLiquidityParams; static readonly SuggestSwaps: SwapClientSuggestSwaps; + static readonly ListReservations: SwapClientListReservations; } export type ServiceError = { message: string, code: number; metadata: grpc.Metadata } @@ -336,5 +346,14 @@ export class SwapClientClient { requestMessage: loop_pb.SuggestSwapsRequest, callback: (error: ServiceError|null, responseMessage: loop_pb.SuggestSwapsResponse|null) => void ): UnaryResponse; + listReservations( + requestMessage: loop_pb.ListReservationsRequest, + metadata: grpc.Metadata, + callback: (error: ServiceError|null, responseMessage: loop_pb.ListReservationsResponse|null) => void + ): UnaryResponse; + listReservations( + requestMessage: loop_pb.ListReservationsRequest, + callback: (error: ServiceError|null, responseMessage: loop_pb.ListReservationsResponse|null) => void + ): UnaryResponse; } diff --git a/app/src/types/generated/loop_pb_service.js b/app/src/types/generated/loop_pb_service.js index af20a7786..2304b88e0 100644 --- a/app/src/types/generated/loop_pb_service.js +++ b/app/src/types/generated/loop_pb_service.js @@ -154,6 +154,15 @@ SwapClient.SuggestSwaps = { responseType: loop_pb.SuggestSwapsResponse }; +SwapClient.ListReservations = { + methodName: "ListReservations", + service: SwapClient, + requestStream: false, + responseStream: false, + requestType: loop_pb.ListReservationsRequest, + responseType: loop_pb.ListReservationsResponse +}; + exports.SwapClient = SwapClient; function SwapClientClient(serviceHost, options) { @@ -665,5 +674,36 @@ SwapClientClient.prototype.suggestSwaps = function suggestSwaps(requestMessage, }; }; +SwapClientClient.prototype.listReservations = function listReservations(requestMessage, metadata, callback) { + if (arguments.length === 2) { + callback = arguments[1]; + } + var client = grpc.unary(SwapClient.ListReservations, { + 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.SwapClientClient = SwapClientClient; diff --git a/app/src/types/generated/swapserverrpc/server_pb.d.ts b/app/src/types/generated/swapserverrpc/server_pb.d.ts index 30b34e4c9..f84450ecc 100644 --- a/app/src/types/generated/swapserverrpc/server_pb.d.ts +++ b/app/src/types/generated/swapserverrpc/server_pb.d.ts @@ -876,6 +876,11 @@ export class MuSig2SignSweepReq extends jspb.Message { getSweepTxPsbt_asB64(): string; setSweepTxPsbt(value: Uint8Array | string): void; + clearPrevoutInfoList(): void; + getPrevoutInfoList(): Array; + setPrevoutInfoList(value: Array): void; + addPrevoutInfo(value?: PrevoutInfo, index?: number): PrevoutInfo; + serializeBinary(): Uint8Array; toObject(includeInstance?: boolean): MuSig2SignSweepReq.AsObject; static toObject(includeInstance: boolean, msg: MuSig2SignSweepReq): MuSig2SignSweepReq.AsObject; @@ -893,6 +898,43 @@ export namespace MuSig2SignSweepReq { paymentAddress: Uint8Array | string, nonce: Uint8Array | string, sweepTxPsbt: Uint8Array | string, + prevoutInfoList: Array, + } +} + +export class PrevoutInfo extends jspb.Message { + getValue(): string; + setValue(value: string): void; + + getPkScript(): Uint8Array | string; + getPkScript_asU8(): Uint8Array; + getPkScript_asB64(): string; + setPkScript(value: Uint8Array | string): void; + + getTxidBytes(): Uint8Array | string; + getTxidBytes_asU8(): Uint8Array; + getTxidBytes_asB64(): string; + setTxidBytes(value: Uint8Array | string): void; + + getOutputIndex(): number; + setOutputIndex(value: number): void; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): PrevoutInfo.AsObject; + static toObject(includeInstance: boolean, msg: PrevoutInfo): PrevoutInfo.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: PrevoutInfo, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): PrevoutInfo; + static deserializeBinaryFromReader(message: PrevoutInfo, reader: jspb.BinaryReader): PrevoutInfo; +} + +export namespace PrevoutInfo { + export type AsObject = { + value: string, + pkScript: Uint8Array | string, + txidBytes: Uint8Array | string, + outputIndex: number, } } @@ -972,6 +1014,38 @@ export namespace ServerPushKeyRes { } } +export class FetchL402Request extends jspb.Message { + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): FetchL402Request.AsObject; + static toObject(includeInstance: boolean, msg: FetchL402Request): FetchL402Request.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: FetchL402Request, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): FetchL402Request; + static deserializeBinaryFromReader(message: FetchL402Request, reader: jspb.BinaryReader): FetchL402Request; +} + +export namespace FetchL402Request { + export type AsObject = { + } +} + +export class FetchL402Response extends jspb.Message { + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): FetchL402Response.AsObject; + static toObject(includeInstance: boolean, msg: FetchL402Response): FetchL402Response.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: FetchL402Response, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): FetchL402Response; + static deserializeBinaryFromReader(message: FetchL402Response, reader: jspb.BinaryReader): FetchL402Response; +} + +export namespace FetchL402Response { + export type AsObject = { + } +} + export interface ProtocolVersionMap { LEGACY: 0; MULTI_LOOP_OUT: 1; diff --git a/app/src/types/generated/swapserverrpc/server_pb.js b/app/src/types/generated/swapserverrpc/server_pb.js index 2650f9fbe..923a2449d 100644 --- a/app/src/types/generated/swapserverrpc/server_pb.js +++ b/app/src/types/generated/swapserverrpc/server_pb.js @@ -17,10 +17,13 @@ var global = Function('return this')(); var swapserverrpc_common_pb = require('../swapserverrpc/common_pb.js'); goog.exportSymbol('proto.looprpc.CancelLoopOutSwapRequest', null, global); goog.exportSymbol('proto.looprpc.CancelLoopOutSwapResponse', null, global); +goog.exportSymbol('proto.looprpc.FetchL402Request', null, global); +goog.exportSymbol('proto.looprpc.FetchL402Response', null, global); goog.exportSymbol('proto.looprpc.HtlcAttempt', null, global); goog.exportSymbol('proto.looprpc.MuSig2SignSweepReq', null, global); goog.exportSymbol('proto.looprpc.MuSig2SignSweepRes', null, global); goog.exportSymbol('proto.looprpc.PaymentFailureReason', null, global); +goog.exportSymbol('proto.looprpc.PrevoutInfo', null, global); goog.exportSymbol('proto.looprpc.ProtocolVersion', null, global); goog.exportSymbol('proto.looprpc.RecommendRoutingPluginReq', null, global); goog.exportSymbol('proto.looprpc.RecommendRoutingPluginRes', null, global); @@ -6228,12 +6231,19 @@ proto.looprpc.ReportRoutingResultRes.serializeBinaryToWriter = function(message, * @constructor */ proto.looprpc.MuSig2SignSweepReq = function(opt_data) { - jspb.Message.initialize(this, opt_data, 0, -1, null, null); + jspb.Message.initialize(this, opt_data, 0, -1, proto.looprpc.MuSig2SignSweepReq.repeatedFields_, null); }; goog.inherits(proto.looprpc.MuSig2SignSweepReq, jspb.Message); if (goog.DEBUG && !COMPILED) { proto.looprpc.MuSig2SignSweepReq.displayName = 'proto.looprpc.MuSig2SignSweepReq'; } +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.looprpc.MuSig2SignSweepReq.repeatedFields_ = [7]; + if (jspb.Message.GENERATE_TO_OBJECT) { @@ -6267,7 +6277,9 @@ proto.looprpc.MuSig2SignSweepReq.toObject = function(includeInstance, msg) { swapHash: msg.getSwapHash_asB64(), paymentAddress: msg.getPaymentAddress_asB64(), nonce: msg.getNonce_asB64(), - sweepTxPsbt: msg.getSweepTxPsbt_asB64() + sweepTxPsbt: msg.getSweepTxPsbt_asB64(), + prevoutInfoList: jspb.Message.toObjectList(msg.getPrevoutInfoList(), + proto.looprpc.PrevoutInfo.toObject, includeInstance) }; if (includeInstance) { @@ -6324,6 +6336,11 @@ proto.looprpc.MuSig2SignSweepReq.deserializeBinaryFromReader = function(msg, rea var value = /** @type {!Uint8Array} */ (reader.readBytes()); msg.setSweepTxPsbt(value); break; + case 7: + var value = new proto.looprpc.PrevoutInfo; + reader.readMessage(value,proto.looprpc.PrevoutInfo.deserializeBinaryFromReader); + msg.addPrevoutInfo(value); + break; default: reader.skipField(); break; @@ -6388,6 +6405,14 @@ proto.looprpc.MuSig2SignSweepReq.serializeBinaryToWriter = function(message, wri f ); } + f = message.getPrevoutInfoList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 7, + f, + proto.looprpc.PrevoutInfo.serializeBinaryToWriter + ); + } }; @@ -6562,6 +6587,308 @@ proto.looprpc.MuSig2SignSweepReq.prototype.setSweepTxPsbt = function(value) { }; +/** + * repeated PrevoutInfo prevout_info = 7; + * @return {!Array} + */ +proto.looprpc.MuSig2SignSweepReq.prototype.getPrevoutInfoList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.looprpc.PrevoutInfo, 7)); +}; + + +/** @param {!Array} value */ +proto.looprpc.MuSig2SignSweepReq.prototype.setPrevoutInfoList = function(value) { + jspb.Message.setRepeatedWrapperField(this, 7, value); +}; + + +/** + * @param {!proto.looprpc.PrevoutInfo=} opt_value + * @param {number=} opt_index + * @return {!proto.looprpc.PrevoutInfo} + */ +proto.looprpc.MuSig2SignSweepReq.prototype.addPrevoutInfo = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 7, opt_value, proto.looprpc.PrevoutInfo, opt_index); +}; + + +proto.looprpc.MuSig2SignSweepReq.prototype.clearPrevoutInfoList = function() { + this.setPrevoutInfoList([]); +}; + + + +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.looprpc.PrevoutInfo = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.looprpc.PrevoutInfo, jspb.Message); +if (goog.DEBUG && !COMPILED) { + proto.looprpc.PrevoutInfo.displayName = 'proto.looprpc.PrevoutInfo'; +} + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto suitable for use in Soy templates. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * com.google.apps.jspb.JsClassTemplate.JS_RESERVED_WORDS. + * @param {boolean=} opt_includeInstance Whether to include the JSPB instance + * for transitional soy proto support: http://goto/soy-param-migration + * @return {!Object} + */ +proto.looprpc.PrevoutInfo.prototype.toObject = function(opt_includeInstance) { + return proto.looprpc.PrevoutInfo.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Whether to include the JSPB + * instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.looprpc.PrevoutInfo} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.looprpc.PrevoutInfo.toObject = function(includeInstance, msg) { + var f, obj = { + value: jspb.Message.getFieldWithDefault(msg, 1, "0"), + pkScript: msg.getPkScript_asB64(), + txidBytes: msg.getTxidBytes_asB64(), + outputIndex: jspb.Message.getFieldWithDefault(msg, 4, 0) + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.looprpc.PrevoutInfo} + */ +proto.looprpc.PrevoutInfo.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.looprpc.PrevoutInfo; + return proto.looprpc.PrevoutInfo.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.looprpc.PrevoutInfo} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.looprpc.PrevoutInfo} + */ +proto.looprpc.PrevoutInfo.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {string} */ (reader.readUint64String()); + msg.setValue(value); + break; + case 2: + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setPkScript(value); + break; + case 3: + var value = /** @type {!Uint8Array} */ (reader.readBytes()); + msg.setTxidBytes(value); + break; + case 4: + var value = /** @type {number} */ (reader.readUint32()); + msg.setOutputIndex(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.looprpc.PrevoutInfo.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.looprpc.PrevoutInfo.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.looprpc.PrevoutInfo} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.looprpc.PrevoutInfo.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getValue(); + if (parseInt(f, 10) !== 0) { + writer.writeUint64String( + 1, + f + ); + } + f = message.getPkScript_asU8(); + if (f.length > 0) { + writer.writeBytes( + 2, + f + ); + } + f = message.getTxidBytes_asU8(); + if (f.length > 0) { + writer.writeBytes( + 3, + f + ); + } + f = message.getOutputIndex(); + if (f !== 0) { + writer.writeUint32( + 4, + f + ); + } +}; + + +/** + * optional uint64 value = 1; + * @return {string} + */ +proto.looprpc.PrevoutInfo.prototype.getValue = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "0")); +}; + + +/** @param {string} value */ +proto.looprpc.PrevoutInfo.prototype.setValue = function(value) { + jspb.Message.setProto3StringIntField(this, 1, value); +}; + + +/** + * optional bytes pk_script = 2; + * @return {!(string|Uint8Array)} + */ +proto.looprpc.PrevoutInfo.prototype.getPkScript = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** + * optional bytes pk_script = 2; + * This is a type-conversion wrapper around `getPkScript()` + * @return {string} + */ +proto.looprpc.PrevoutInfo.prototype.getPkScript_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getPkScript())); +}; + + +/** + * optional bytes pk_script = 2; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getPkScript()` + * @return {!Uint8Array} + */ +proto.looprpc.PrevoutInfo.prototype.getPkScript_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getPkScript())); +}; + + +/** @param {!(string|Uint8Array)} value */ +proto.looprpc.PrevoutInfo.prototype.setPkScript = function(value) { + jspb.Message.setProto3BytesField(this, 2, value); +}; + + +/** + * optional bytes txid_bytes = 3; + * @return {!(string|Uint8Array)} + */ +proto.looprpc.PrevoutInfo.prototype.getTxidBytes = function() { + return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 3, "")); +}; + + +/** + * optional bytes txid_bytes = 3; + * This is a type-conversion wrapper around `getTxidBytes()` + * @return {string} + */ +proto.looprpc.PrevoutInfo.prototype.getTxidBytes_asB64 = function() { + return /** @type {string} */ (jspb.Message.bytesAsB64( + this.getTxidBytes())); +}; + + +/** + * optional bytes txid_bytes = 3; + * Note that Uint8Array is not supported on all browsers. + * @see http://caniuse.com/Uint8Array + * This is a type-conversion wrapper around `getTxidBytes()` + * @return {!Uint8Array} + */ +proto.looprpc.PrevoutInfo.prototype.getTxidBytes_asU8 = function() { + return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8( + this.getTxidBytes())); +}; + + +/** @param {!(string|Uint8Array)} value */ +proto.looprpc.PrevoutInfo.prototype.setTxidBytes = function(value) { + jspb.Message.setProto3BytesField(this, 3, value); +}; + + +/** + * optional uint32 output_index = 4; + * @return {number} + */ +proto.looprpc.PrevoutInfo.prototype.getOutputIndex = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 4, 0)); +}; + + +/** @param {number} value */ +proto.looprpc.PrevoutInfo.prototype.setOutputIndex = function(value) { + jspb.Message.setProto3IntField(this, 4, value); +}; + + /** * Generated by JsPbCodeGenerator. @@ -7139,6 +7466,238 @@ proto.looprpc.ServerPushKeyRes.serializeBinaryToWriter = function(message, write }; + +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.looprpc.FetchL402Request = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.looprpc.FetchL402Request, jspb.Message); +if (goog.DEBUG && !COMPILED) { + proto.looprpc.FetchL402Request.displayName = 'proto.looprpc.FetchL402Request'; +} + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto suitable for use in Soy templates. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * com.google.apps.jspb.JsClassTemplate.JS_RESERVED_WORDS. + * @param {boolean=} opt_includeInstance Whether to include the JSPB instance + * for transitional soy proto support: http://goto/soy-param-migration + * @return {!Object} + */ +proto.looprpc.FetchL402Request.prototype.toObject = function(opt_includeInstance) { + return proto.looprpc.FetchL402Request.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Whether to include the JSPB + * instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.looprpc.FetchL402Request} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.looprpc.FetchL402Request.toObject = function(includeInstance, msg) { + var f, obj = { + + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.looprpc.FetchL402Request} + */ +proto.looprpc.FetchL402Request.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.looprpc.FetchL402Request; + return proto.looprpc.FetchL402Request.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.looprpc.FetchL402Request} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.looprpc.FetchL402Request} + */ +proto.looprpc.FetchL402Request.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.looprpc.FetchL402Request.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.looprpc.FetchL402Request.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.looprpc.FetchL402Request} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.looprpc.FetchL402Request.serializeBinaryToWriter = function(message, writer) { + var f = undefined; +}; + + + +/** + * Generated by JsPbCodeGenerator. + * @param {Array=} opt_data Optional initial data array, typically from a + * server response, or constructed directly in Javascript. The array is used + * in place and becomes part of the constructed object. It is not cloned. + * If no data is provided, the constructed object will be empty, but still + * valid. + * @extends {jspb.Message} + * @constructor + */ +proto.looprpc.FetchL402Response = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.looprpc.FetchL402Response, jspb.Message); +if (goog.DEBUG && !COMPILED) { + proto.looprpc.FetchL402Response.displayName = 'proto.looprpc.FetchL402Response'; +} + + +if (jspb.Message.GENERATE_TO_OBJECT) { +/** + * Creates an object representation of this proto suitable for use in Soy templates. + * Field names that are reserved in JavaScript and will be renamed to pb_name. + * To access a reserved field use, foo.pb_, eg, foo.pb_default. + * For the list of reserved names please see: + * com.google.apps.jspb.JsClassTemplate.JS_RESERVED_WORDS. + * @param {boolean=} opt_includeInstance Whether to include the JSPB instance + * for transitional soy proto support: http://goto/soy-param-migration + * @return {!Object} + */ +proto.looprpc.FetchL402Response.prototype.toObject = function(opt_includeInstance) { + return proto.looprpc.FetchL402Response.toObject(opt_includeInstance, this); +}; + + +/** + * Static version of the {@see toObject} method. + * @param {boolean|undefined} includeInstance Whether to include the JSPB + * instance for transitional soy proto support: + * http://goto/soy-param-migration + * @param {!proto.looprpc.FetchL402Response} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.looprpc.FetchL402Response.toObject = function(includeInstance, msg) { + var f, obj = { + + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.looprpc.FetchL402Response} + */ +proto.looprpc.FetchL402Response.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.looprpc.FetchL402Response; + return proto.looprpc.FetchL402Response.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.looprpc.FetchL402Response} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.looprpc.FetchL402Response} + */ +proto.looprpc.FetchL402Response.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.looprpc.FetchL402Response.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.looprpc.FetchL402Response.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.looprpc.FetchL402Response} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.looprpc.FetchL402Response.serializeBinaryToWriter = function(message, writer) { + var f = undefined; +}; + + /** * @enum {number} */ diff --git a/app/src/types/generated/swapserverrpc/server_pb_service.d.ts b/app/src/types/generated/swapserverrpc/server_pb_service.d.ts index d6ffba874..2ead735c8 100644 --- a/app/src/types/generated/swapserverrpc/server_pb_service.d.ts +++ b/app/src/types/generated/swapserverrpc/server_pb_service.d.ts @@ -139,6 +139,15 @@ type SwapServerPushKey = { readonly responseType: typeof swapserverrpc_server_pb.ServerPushKeyRes; }; +type SwapServerFetchL402 = { + readonly methodName: string; + readonly service: typeof SwapServer; + readonly requestStream: false; + readonly responseStream: false; + readonly requestType: typeof swapserverrpc_server_pb.FetchL402Request; + readonly responseType: typeof swapserverrpc_server_pb.FetchL402Response; +}; + export class SwapServer { static readonly serviceName: string; static readonly LoopOutTerms: SwapServerLoopOutTerms; @@ -156,6 +165,7 @@ export class SwapServer { static readonly ReportRoutingResult: SwapServerReportRoutingResult; static readonly MuSig2SignSweep: SwapServerMuSig2SignSweep; static readonly PushKey: SwapServerPushKey; + static readonly FetchL402: SwapServerFetchL402; } export type ServiceError = { message: string, code: number; metadata: grpc.Metadata } @@ -309,5 +319,14 @@ export class SwapServerClient { requestMessage: swapserverrpc_server_pb.ServerPushKeyReq, callback: (error: ServiceError|null, responseMessage: swapserverrpc_server_pb.ServerPushKeyRes|null) => void ): UnaryResponse; + fetchL402( + requestMessage: swapserverrpc_server_pb.FetchL402Request, + metadata: grpc.Metadata, + callback: (error: ServiceError|null, responseMessage: swapserverrpc_server_pb.FetchL402Response|null) => void + ): UnaryResponse; + fetchL402( + requestMessage: swapserverrpc_server_pb.FetchL402Request, + callback: (error: ServiceError|null, responseMessage: swapserverrpc_server_pb.FetchL402Response|null) => void + ): UnaryResponse; } diff --git a/app/src/types/generated/swapserverrpc/server_pb_service.js b/app/src/types/generated/swapserverrpc/server_pb_service.js index 2ef133707..cf2c35127 100644 --- a/app/src/types/generated/swapserverrpc/server_pb_service.js +++ b/app/src/types/generated/swapserverrpc/server_pb_service.js @@ -145,6 +145,15 @@ SwapServer.PushKey = { responseType: swapserverrpc_server_pb.ServerPushKeyRes }; +SwapServer.FetchL402 = { + methodName: "FetchL402", + service: SwapServer, + requestStream: false, + responseStream: false, + requestType: swapserverrpc_server_pb.FetchL402Request, + responseType: swapserverrpc_server_pb.FetchL402Response +}; + exports.SwapServer = SwapServer; function SwapServerClient(serviceHost, options) { @@ -633,5 +642,36 @@ SwapServerClient.prototype.pushKey = function pushKey(requestMessage, metadata, }; }; +SwapServerClient.prototype.fetchL402 = function fetchL402(requestMessage, metadata, callback) { + if (arguments.length === 2) { + callback = arguments[1]; + } + var client = grpc.unary(SwapServer.FetchL402, { + 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.SwapServerClient = SwapServerClient; diff --git a/proto/loop.proto b/proto/loop.proto index 164ee8561..d405c70e1 100644 --- a/proto/loop.proto +++ b/proto/loop.proto @@ -109,6 +109,12 @@ service SwapClient { [EXPERIMENTAL]: endpoint is subject to change. */ rpc SuggestSwaps (SuggestSwapsRequest) returns (SuggestSwapsResponse); + + /* loop: `listreservations` + ListReservations returns a list of all reservations the server opened to us. + */ + rpc ListReservations (ListReservationsRequest) + returns (ListReservationsResponse); } message LoopOutRequest { @@ -229,6 +235,13 @@ message LoopOutRequest { The address type of the account specified in the account field. */ AddressType account_addr_type = 16; + + /* + A flag indicating whether the defined destination address does not belong to + the wallet. This is used to flag whether this loop out swap could have its + associated sweep batched. + */ + bool is_external_addr = 17; } /* @@ -544,6 +557,34 @@ enum FailureReason { } message ListSwapsRequest { + // Optional filter to only return swaps that match the filter. + ListSwapsFilter list_swap_filter = 1; +} + +message ListSwapsFilter { + enum SwapTypeFilter { + // ANY indicates that no filter is applied. + ANY = 0; + // LOOP_OUT indicates an loop out swap (off-chain to on-chain). + LOOP_OUT = 1; + + // LOOP_IN indicates a loop in swap (on-chain to off-chain). + LOOP_IN = 2; + } + // The type of the swap. + SwapTypeFilter swap_type = 1; + + // If set, only pending swaps are returned. + bool pending_only = 2; + + // If specified on creation, the outgoing channel set of the swap. + repeated uint64 outgoing_chan_set = 3 [jstype = JS_STRING]; + + // Label of swap to filter for. + string label = 4; + + // If specified on creation, the last hop of the swap. + bytes loop_in_last_hop = 5; } message ListSwapsResponse { @@ -1214,4 +1255,42 @@ message AbandonSwapRequest { } message AbandonSwapResponse { +} + +message ListReservationsRequest { +} + +message ListReservationsResponse { + /* + The list of all currently known reservations and their status. + */ + repeated ClientReservation reservations = 1; +} + +message ClientReservation { + /* + The reservation id that identifies this reservation. + */ + bytes reservation_id = 1; + + /* + The state the reservation is in. + */ + string state = 2; + /* + The amount that the reservation is for. + */ + uint64 amount = 3 [jstype = JS_STRING]; + /* + The transaction id of the reservation. + */ + bytes tx_id = 4; + /* + The vout of the reservation. + */ + uint32 vout = 5; + /* + The expiry of the reservation. + */ + uint32 expiry = 6; } \ No newline at end of file diff --git a/proto/swapserverrpc/server.proto b/proto/swapserverrpc/server.proto index 14b7ab320..1414e0aa9 100644 --- a/proto/swapserverrpc/server.proto +++ b/proto/swapserverrpc/server.proto @@ -1,12 +1,11 @@ syntax = "proto3"; -import "swapserverrpc/common.proto"; - // We can't change this to swapserverrpc, it would be a breaking change because // the package name is also contained in the HTTP URIs and old clients would // call the wrong endpoints. Luckily with the go_package option we can have // different golang and RPC package names to fix protobuf namespace conflicts. package looprpc; +import "swapserverrpc/common.proto"; option go_package = "github.com/lightninglabs/loop/swapserverrpc"; @@ -47,6 +46,10 @@ service SwapServer { rpc MuSig2SignSweep (MuSig2SignSweepReq) returns (MuSig2SignSweepRes); rpc PushKey (ServerPushKeyReq) returns (ServerPushKeyRes); + + // FetchL402 is a simple non-l402-allowlisted request that is required + // in order to force the creation of an l402. + rpc FetchL402 (FetchL402Request) returns (FetchL402Response); } /** @@ -511,7 +514,6 @@ message ServerProbeRequest { // The protocol version that the client adheres to. ProtocolVersion protocol_version = 1; - // The probe amount. uint64 amt = 2 [jstype = JS_STRING]; // The target node for the probe. @@ -594,6 +596,23 @@ message MuSig2SignSweepReq { // The psbt of the sweep txn. bytes sweep_tx_psbt = 6; + + // The prevout information of the sweep txn. + repeated PrevoutInfo prevout_info = 7; +} + +message PrevoutInfo { + // The value of the txout. + uint64 value = 1 [jstype = JS_STRING]; + + // The pk_script of the txout. + bytes pk_script = 2; + + // The txid of the txout. + bytes txid_bytes = 3; + + // The index of the txout. + uint32 output_index = 4; } message MuSig2SignSweepRes { @@ -617,3 +636,13 @@ message ServerPushKeyReq { message ServerPushKeyRes { } + +// FetchL402Request is an empty request sent from the client to the server to +// fetch the lnd l402. +message FetchL402Request { +} + +// FetchL402Response is an empty response sent from the server to the client to +// confirm the lnd l402. +message FetchL402Response { +} \ No newline at end of file