From 037fa9a2cccb77706be433619a672d4dfbb329d9 Mon Sep 17 00:00:00 2001 From: Oliver Gugger Date: Wed, 29 Mar 2023 20:34:36 +0200 Subject: [PATCH] mod: bump pool to v0.6.2-beta --- app/src/types/generated/trader_pb.d.ts | 113 +++ app/src/types/generated/trader_pb.js | 795 +++++++++++++++++- .../types/generated/trader_pb_service.d.ts | 19 + app/src/types/generated/trader_pb_service.js | 40 + go.mod | 2 +- go.sum | 4 +- proto/trader.proto | 57 +- 7 files changed, 1025 insertions(+), 5 deletions(-) diff --git a/app/src/types/generated/trader_pb.d.ts b/app/src/types/generated/trader_pb.d.ts index 5a163ec2..370ef4b7 100644 --- a/app/src/types/generated/trader_pb.d.ts +++ b/app/src/types/generated/trader_pb.d.ts @@ -1262,6 +1262,118 @@ export namespace RecoverAccountsResponse { } } +export class AccountModificationFeesRequest extends jspb.Message { + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): AccountModificationFeesRequest.AsObject; + static toObject(includeInstance: boolean, msg: AccountModificationFeesRequest): AccountModificationFeesRequest.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: AccountModificationFeesRequest, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): AccountModificationFeesRequest; + static deserializeBinaryFromReader(message: AccountModificationFeesRequest, reader: jspb.BinaryReader): AccountModificationFeesRequest; +} + +export namespace AccountModificationFeesRequest { + export type AsObject = { + } +} + +export class AccountModificationFee extends jspb.Message { + getAction(): string; + setAction(value: string): void; + + getTxid(): string; + setTxid(value: string): void; + + getBlockHeight(): number; + setBlockHeight(value: number): void; + + getTimestamp(): string; + setTimestamp(value: string): void; + + getOutputAmount(): string; + setOutputAmount(value: string): void; + + hasFeeNull(): boolean; + clearFeeNull(): void; + getFeeNull(): boolean; + setFeeNull(value: boolean): void; + + hasFeeValue(): boolean; + clearFeeValue(): void; + getFeeValue(): string; + setFeeValue(value: string): void; + + getFeeCase(): AccountModificationFee.FeeCase; + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): AccountModificationFee.AsObject; + static toObject(includeInstance: boolean, msg: AccountModificationFee): AccountModificationFee.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: AccountModificationFee, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): AccountModificationFee; + static deserializeBinaryFromReader(message: AccountModificationFee, reader: jspb.BinaryReader): AccountModificationFee; +} + +export namespace AccountModificationFee { + export type AsObject = { + action: string, + txid: string, + blockHeight: number, + timestamp: string, + outputAmount: string, + feeNull: boolean, + feeValue: string, + } + + export enum FeeCase { + FEE_NOT_SET = 0, + FEE_NULL = 6, + FEE_VALUE = 7, + } +} + +export class ListOfAccountModificationFees extends jspb.Message { + clearModificationFeesList(): void; + getModificationFeesList(): Array; + setModificationFeesList(value: Array): void; + addModificationFees(value?: AccountModificationFee, index?: number): AccountModificationFee; + + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): ListOfAccountModificationFees.AsObject; + static toObject(includeInstance: boolean, msg: ListOfAccountModificationFees): ListOfAccountModificationFees.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: ListOfAccountModificationFees, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): ListOfAccountModificationFees; + static deserializeBinaryFromReader(message: ListOfAccountModificationFees, reader: jspb.BinaryReader): ListOfAccountModificationFees; +} + +export namespace ListOfAccountModificationFees { + export type AsObject = { + modificationFeesList: Array, + } +} + +export class AccountModificationFeesResponse extends jspb.Message { + getAccountsMap(): jspb.Map; + clearAccountsMap(): void; + serializeBinary(): Uint8Array; + toObject(includeInstance?: boolean): AccountModificationFeesResponse.AsObject; + static toObject(includeInstance: boolean, msg: AccountModificationFeesResponse): AccountModificationFeesResponse.AsObject; + static extensions: {[key: number]: jspb.ExtensionFieldInfo}; + static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo}; + static serializeBinaryToWriter(message: AccountModificationFeesResponse, writer: jspb.BinaryWriter): void; + static deserializeBinary(bytes: Uint8Array): AccountModificationFeesResponse; + static deserializeBinaryFromReader(message: AccountModificationFeesResponse, reader: jspb.BinaryReader): AccountModificationFeesResponse; +} + +export namespace AccountModificationFeesResponse { + export type AsObject = { + accountsMap: Array<[string, ListOfAccountModificationFees.AsObject]>, + } +} + export class AuctionFeeRequest extends jspb.Message { serializeBinary(): Uint8Array; toObject(includeInstance?: boolean): AuctionFeeRequest.AsObject; @@ -2092,6 +2204,7 @@ export interface AccountVersionMap { ACCOUNT_VERSION_LND_DEPENDENT: 0; ACCOUNT_VERSION_LEGACY: 1; ACCOUNT_VERSION_TAPROOT: 2; + ACCOUNT_VERSION_TAPROOT_V2: 3; } export const AccountVersion: AccountVersionMap; diff --git a/app/src/types/generated/trader_pb.js b/app/src/types/generated/trader_pb.js index 776ce6fa..fbf03abc 100644 --- a/app/src/types/generated/trader_pb.js +++ b/app/src/types/generated/trader_pb.js @@ -16,6 +16,9 @@ var global = Function('return this')(); var auctioneerrpc_auctioneer_pb = require('./auctioneerrpc/auctioneer_pb.js'); goog.exportSymbol('proto.poolrpc.Account', null, global); +goog.exportSymbol('proto.poolrpc.AccountModificationFee', null, global); +goog.exportSymbol('proto.poolrpc.AccountModificationFeesRequest', null, global); +goog.exportSymbol('proto.poolrpc.AccountModificationFeesResponse', null, global); goog.exportSymbol('proto.poolrpc.AccountState', null, global); goog.exportSymbol('proto.poolrpc.AccountVersion', null, global); goog.exportSymbol('proto.poolrpc.Ask', null, global); @@ -45,6 +48,7 @@ goog.exportSymbol('proto.poolrpc.LeasesRequest', null, global); goog.exportSymbol('proto.poolrpc.LeasesResponse', null, global); goog.exportSymbol('proto.poolrpc.ListAccountsRequest', null, global); goog.exportSymbol('proto.poolrpc.ListAccountsResponse', null, global); +goog.exportSymbol('proto.poolrpc.ListOfAccountModificationFees', null, global); goog.exportSymbol('proto.poolrpc.ListOrdersRequest', null, global); goog.exportSymbol('proto.poolrpc.ListOrdersResponse', null, global); goog.exportSymbol('proto.poolrpc.ListSidecarsRequest', null, global); @@ -8912,6 +8916,794 @@ proto.poolrpc.RecoverAccountsResponse.prototype.setNumRecoveredAccounts = functi +/** + * 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.poolrpc.AccountModificationFeesRequest = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.poolrpc.AccountModificationFeesRequest, jspb.Message); +if (goog.DEBUG && !COMPILED) { + proto.poolrpc.AccountModificationFeesRequest.displayName = 'proto.poolrpc.AccountModificationFeesRequest'; +} + + +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.poolrpc.AccountModificationFeesRequest.prototype.toObject = function(opt_includeInstance) { + return proto.poolrpc.AccountModificationFeesRequest.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.poolrpc.AccountModificationFeesRequest} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.poolrpc.AccountModificationFeesRequest.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.poolrpc.AccountModificationFeesRequest} + */ +proto.poolrpc.AccountModificationFeesRequest.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.poolrpc.AccountModificationFeesRequest; + return proto.poolrpc.AccountModificationFeesRequest.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.poolrpc.AccountModificationFeesRequest} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.poolrpc.AccountModificationFeesRequest} + */ +proto.poolrpc.AccountModificationFeesRequest.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.poolrpc.AccountModificationFeesRequest.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.poolrpc.AccountModificationFeesRequest.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.poolrpc.AccountModificationFeesRequest} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.poolrpc.AccountModificationFeesRequest.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.poolrpc.AccountModificationFee = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, proto.poolrpc.AccountModificationFee.oneofGroups_); +}; +goog.inherits(proto.poolrpc.AccountModificationFee, jspb.Message); +if (goog.DEBUG && !COMPILED) { + proto.poolrpc.AccountModificationFee.displayName = 'proto.poolrpc.AccountModificationFee'; +} +/** + * Oneof group definitions for this message. Each group defines the field + * numbers belonging to that group. When of these fields' value is set, all + * other fields in the group are cleared. During deserialization, if multiple + * fields are encountered for a group, only the last value seen will be kept. + * @private {!Array>} + * @const + */ +proto.poolrpc.AccountModificationFee.oneofGroups_ = [[6,7]]; + +/** + * @enum {number} + */ +proto.poolrpc.AccountModificationFee.FeeCase = { + FEE_NOT_SET: 0, + FEE_NULL: 6, + FEE_VALUE: 7 +}; + +/** + * @return {proto.poolrpc.AccountModificationFee.FeeCase} + */ +proto.poolrpc.AccountModificationFee.prototype.getFeeCase = function() { + return /** @type {proto.poolrpc.AccountModificationFee.FeeCase} */(jspb.Message.computeOneofCase(this, proto.poolrpc.AccountModificationFee.oneofGroups_[0])); +}; + + + +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.poolrpc.AccountModificationFee.prototype.toObject = function(opt_includeInstance) { + return proto.poolrpc.AccountModificationFee.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.poolrpc.AccountModificationFee} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.poolrpc.AccountModificationFee.toObject = function(includeInstance, msg) { + var f, obj = { + action: jspb.Message.getFieldWithDefault(msg, 1, ""), + txid: jspb.Message.getFieldWithDefault(msg, 2, ""), + blockHeight: jspb.Message.getFieldWithDefault(msg, 3, 0), + timestamp: jspb.Message.getFieldWithDefault(msg, 4, "0"), + outputAmount: jspb.Message.getFieldWithDefault(msg, 5, "0"), + feeNull: jspb.Message.getFieldWithDefault(msg, 6, false), + feeValue: jspb.Message.getFieldWithDefault(msg, 7, "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.poolrpc.AccountModificationFee} + */ +proto.poolrpc.AccountModificationFee.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.poolrpc.AccountModificationFee; + return proto.poolrpc.AccountModificationFee.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.poolrpc.AccountModificationFee} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.poolrpc.AccountModificationFee} + */ +proto.poolrpc.AccountModificationFee.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = /** @type {string} */ (reader.readString()); + msg.setAction(value); + break; + case 2: + var value = /** @type {string} */ (reader.readString()); + msg.setTxid(value); + break; + case 3: + var value = /** @type {number} */ (reader.readInt32()); + msg.setBlockHeight(value); + break; + case 4: + var value = /** @type {string} */ (reader.readInt64String()); + msg.setTimestamp(value); + break; + case 5: + var value = /** @type {string} */ (reader.readInt64String()); + msg.setOutputAmount(value); + break; + case 6: + var value = /** @type {boolean} */ (reader.readBool()); + msg.setFeeNull(value); + break; + case 7: + var value = /** @type {string} */ (reader.readInt64String()); + msg.setFeeValue(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.poolrpc.AccountModificationFee.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.poolrpc.AccountModificationFee.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.poolrpc.AccountModificationFee} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.poolrpc.AccountModificationFee.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getAction(); + if (f.length > 0) { + writer.writeString( + 1, + f + ); + } + f = message.getTxid(); + if (f.length > 0) { + writer.writeString( + 2, + f + ); + } + f = message.getBlockHeight(); + if (f !== 0) { + writer.writeInt32( + 3, + f + ); + } + f = message.getTimestamp(); + if (parseInt(f, 10) !== 0) { + writer.writeInt64String( + 4, + f + ); + } + f = message.getOutputAmount(); + if (parseInt(f, 10) !== 0) { + writer.writeInt64String( + 5, + f + ); + } + f = /** @type {boolean} */ (jspb.Message.getField(message, 6)); + if (f != null) { + writer.writeBool( + 6, + f + ); + } + f = /** @type {string} */ (jspb.Message.getField(message, 7)); + if (f != null) { + writer.writeInt64String( + 7, + f + ); + } +}; + + +/** + * optional string action = 1; + * @return {string} + */ +proto.poolrpc.AccountModificationFee.prototype.getAction = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, "")); +}; + + +/** @param {string} value */ +proto.poolrpc.AccountModificationFee.prototype.setAction = function(value) { + jspb.Message.setProto3StringField(this, 1, value); +}; + + +/** + * optional string txid = 2; + * @return {string} + */ +proto.poolrpc.AccountModificationFee.prototype.getTxid = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, "")); +}; + + +/** @param {string} value */ +proto.poolrpc.AccountModificationFee.prototype.setTxid = function(value) { + jspb.Message.setProto3StringField(this, 2, value); +}; + + +/** + * optional int32 block_height = 3; + * @return {number} + */ +proto.poolrpc.AccountModificationFee.prototype.getBlockHeight = function() { + return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 3, 0)); +}; + + +/** @param {number} value */ +proto.poolrpc.AccountModificationFee.prototype.setBlockHeight = function(value) { + jspb.Message.setProto3IntField(this, 3, value); +}; + + +/** + * optional int64 timestamp = 4; + * @return {string} + */ +proto.poolrpc.AccountModificationFee.prototype.getTimestamp = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, "0")); +}; + + +/** @param {string} value */ +proto.poolrpc.AccountModificationFee.prototype.setTimestamp = function(value) { + jspb.Message.setProto3StringIntField(this, 4, value); +}; + + +/** + * optional int64 output_amount = 5; + * @return {string} + */ +proto.poolrpc.AccountModificationFee.prototype.getOutputAmount = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 5, "0")); +}; + + +/** @param {string} value */ +proto.poolrpc.AccountModificationFee.prototype.setOutputAmount = function(value) { + jspb.Message.setProto3StringIntField(this, 5, value); +}; + + +/** + * optional bool fee_null = 6; + * 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.poolrpc.AccountModificationFee.prototype.getFeeNull = function() { + return /** @type {boolean} */ (jspb.Message.getFieldWithDefault(this, 6, false)); +}; + + +/** @param {boolean} value */ +proto.poolrpc.AccountModificationFee.prototype.setFeeNull = function(value) { + jspb.Message.setOneofField(this, 6, proto.poolrpc.AccountModificationFee.oneofGroups_[0], value); +}; + + +proto.poolrpc.AccountModificationFee.prototype.clearFeeNull = function() { + jspb.Message.setOneofField(this, 6, proto.poolrpc.AccountModificationFee.oneofGroups_[0], undefined); +}; + + +/** + * Returns whether this field is set. + * @return {!boolean} + */ +proto.poolrpc.AccountModificationFee.prototype.hasFeeNull = function() { + return jspb.Message.getField(this, 6) != null; +}; + + +/** + * optional int64 fee_value = 7; + * @return {string} + */ +proto.poolrpc.AccountModificationFee.prototype.getFeeValue = function() { + return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 7, "0")); +}; + + +/** @param {string} value */ +proto.poolrpc.AccountModificationFee.prototype.setFeeValue = function(value) { + jspb.Message.setOneofField(this, 7, proto.poolrpc.AccountModificationFee.oneofGroups_[0], value); +}; + + +proto.poolrpc.AccountModificationFee.prototype.clearFeeValue = function() { + jspb.Message.setOneofField(this, 7, proto.poolrpc.AccountModificationFee.oneofGroups_[0], undefined); +}; + + +/** + * Returns whether this field is set. + * @return {!boolean} + */ +proto.poolrpc.AccountModificationFee.prototype.hasFeeValue = function() { + return jspb.Message.getField(this, 7) != null; +}; + + + +/** + * 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.poolrpc.ListOfAccountModificationFees = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, proto.poolrpc.ListOfAccountModificationFees.repeatedFields_, null); +}; +goog.inherits(proto.poolrpc.ListOfAccountModificationFees, jspb.Message); +if (goog.DEBUG && !COMPILED) { + proto.poolrpc.ListOfAccountModificationFees.displayName = 'proto.poolrpc.ListOfAccountModificationFees'; +} +/** + * List of repeated fields within this message type. + * @private {!Array} + * @const + */ +proto.poolrpc.ListOfAccountModificationFees.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.poolrpc.ListOfAccountModificationFees.prototype.toObject = function(opt_includeInstance) { + return proto.poolrpc.ListOfAccountModificationFees.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.poolrpc.ListOfAccountModificationFees} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.poolrpc.ListOfAccountModificationFees.toObject = function(includeInstance, msg) { + var f, obj = { + modificationFeesList: jspb.Message.toObjectList(msg.getModificationFeesList(), + proto.poolrpc.AccountModificationFee.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.poolrpc.ListOfAccountModificationFees} + */ +proto.poolrpc.ListOfAccountModificationFees.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.poolrpc.ListOfAccountModificationFees; + return proto.poolrpc.ListOfAccountModificationFees.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.poolrpc.ListOfAccountModificationFees} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.poolrpc.ListOfAccountModificationFees} + */ +proto.poolrpc.ListOfAccountModificationFees.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = new proto.poolrpc.AccountModificationFee; + reader.readMessage(value,proto.poolrpc.AccountModificationFee.deserializeBinaryFromReader); + msg.addModificationFees(value); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.poolrpc.ListOfAccountModificationFees.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.poolrpc.ListOfAccountModificationFees.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.poolrpc.ListOfAccountModificationFees} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.poolrpc.ListOfAccountModificationFees.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getModificationFeesList(); + if (f.length > 0) { + writer.writeRepeatedMessage( + 1, + f, + proto.poolrpc.AccountModificationFee.serializeBinaryToWriter + ); + } +}; + + +/** + * repeated AccountModificationFee modification_fees = 1; + * @return {!Array} + */ +proto.poolrpc.ListOfAccountModificationFees.prototype.getModificationFeesList = function() { + return /** @type{!Array} */ ( + jspb.Message.getRepeatedWrapperField(this, proto.poolrpc.AccountModificationFee, 1)); +}; + + +/** @param {!Array} value */ +proto.poolrpc.ListOfAccountModificationFees.prototype.setModificationFeesList = function(value) { + jspb.Message.setRepeatedWrapperField(this, 1, value); +}; + + +/** + * @param {!proto.poolrpc.AccountModificationFee=} opt_value + * @param {number=} opt_index + * @return {!proto.poolrpc.AccountModificationFee} + */ +proto.poolrpc.ListOfAccountModificationFees.prototype.addModificationFees = function(opt_value, opt_index) { + return jspb.Message.addToRepeatedWrapperField(this, 1, opt_value, proto.poolrpc.AccountModificationFee, opt_index); +}; + + +proto.poolrpc.ListOfAccountModificationFees.prototype.clearModificationFeesList = function() { + this.setModificationFeesList([]); +}; + + + +/** + * 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.poolrpc.AccountModificationFeesResponse = function(opt_data) { + jspb.Message.initialize(this, opt_data, 0, -1, null, null); +}; +goog.inherits(proto.poolrpc.AccountModificationFeesResponse, jspb.Message); +if (goog.DEBUG && !COMPILED) { + proto.poolrpc.AccountModificationFeesResponse.displayName = 'proto.poolrpc.AccountModificationFeesResponse'; +} + + +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.poolrpc.AccountModificationFeesResponse.prototype.toObject = function(opt_includeInstance) { + return proto.poolrpc.AccountModificationFeesResponse.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.poolrpc.AccountModificationFeesResponse} msg The msg instance to transform. + * @return {!Object} + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.poolrpc.AccountModificationFeesResponse.toObject = function(includeInstance, msg) { + var f, obj = { + accountsMap: (f = msg.getAccountsMap()) ? f.toObject(includeInstance, proto.poolrpc.ListOfAccountModificationFees.toObject) : [] + }; + + if (includeInstance) { + obj.$jspbMessageInstance = msg; + } + return obj; +}; +} + + +/** + * Deserializes binary data (in protobuf wire format). + * @param {jspb.ByteSource} bytes The bytes to deserialize. + * @return {!proto.poolrpc.AccountModificationFeesResponse} + */ +proto.poolrpc.AccountModificationFeesResponse.deserializeBinary = function(bytes) { + var reader = new jspb.BinaryReader(bytes); + var msg = new proto.poolrpc.AccountModificationFeesResponse; + return proto.poolrpc.AccountModificationFeesResponse.deserializeBinaryFromReader(msg, reader); +}; + + +/** + * Deserializes binary data (in protobuf wire format) from the + * given reader into the given message object. + * @param {!proto.poolrpc.AccountModificationFeesResponse} msg The message object to deserialize into. + * @param {!jspb.BinaryReader} reader The BinaryReader to use. + * @return {!proto.poolrpc.AccountModificationFeesResponse} + */ +proto.poolrpc.AccountModificationFeesResponse.deserializeBinaryFromReader = function(msg, reader) { + while (reader.nextField()) { + if (reader.isEndGroup()) { + break; + } + var field = reader.getFieldNumber(); + switch (field) { + case 1: + var value = msg.getAccountsMap(); + reader.readMessage(value, function(message, reader) { + jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readMessage, proto.poolrpc.ListOfAccountModificationFees.deserializeBinaryFromReader, ""); + }); + break; + default: + reader.skipField(); + break; + } + } + return msg; +}; + + +/** + * Serializes the message to binary data (in protobuf wire format). + * @return {!Uint8Array} + */ +proto.poolrpc.AccountModificationFeesResponse.prototype.serializeBinary = function() { + var writer = new jspb.BinaryWriter(); + proto.poolrpc.AccountModificationFeesResponse.serializeBinaryToWriter(this, writer); + return writer.getResultBuffer(); +}; + + +/** + * Serializes the given message to binary data (in protobuf wire + * format), writing to the given BinaryWriter. + * @param {!proto.poolrpc.AccountModificationFeesResponse} message + * @param {!jspb.BinaryWriter} writer + * @suppress {unusedLocalVariables} f is only used for nested messages + */ +proto.poolrpc.AccountModificationFeesResponse.serializeBinaryToWriter = function(message, writer) { + var f = undefined; + f = message.getAccountsMap(true); + if (f && f.getLength() > 0) { + f.serializeBinary(1, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeMessage, proto.poolrpc.ListOfAccountModificationFees.serializeBinaryToWriter); + } +}; + + +/** + * map accounts = 1; + * @param {boolean=} opt_noLazyCreate Do not create the map if + * empty, instead returning `undefined` + * @return {!jspb.Map} + */ +proto.poolrpc.AccountModificationFeesResponse.prototype.getAccountsMap = function(opt_noLazyCreate) { + return /** @type {!jspb.Map} */ ( + jspb.Message.getMapField(this, 1, opt_noLazyCreate, + proto.poolrpc.ListOfAccountModificationFees)); +}; + + +proto.poolrpc.AccountModificationFeesResponse.prototype.clearAccountsMap = function() { + this.getAccountsMap().clear(); +}; + + + /** * Generated by JsPbCodeGenerator. * @param {Array=} opt_data Optional initial data array, typically from a @@ -15014,7 +15806,8 @@ proto.poolrpc.CancelSidecarResponse.serializeBinaryToWriter = function(message, proto.poolrpc.AccountVersion = { ACCOUNT_VERSION_LND_DEPENDENT: 0, ACCOUNT_VERSION_LEGACY: 1, - ACCOUNT_VERSION_TAPROOT: 2 + ACCOUNT_VERSION_TAPROOT: 2, + ACCOUNT_VERSION_TAPROOT_V2: 3 }; /** diff --git a/app/src/types/generated/trader_pb_service.d.ts b/app/src/types/generated/trader_pb_service.d.ts index 8d0f6ea4..32fcc7ce 100644 --- a/app/src/types/generated/trader_pb_service.d.ts +++ b/app/src/types/generated/trader_pb_service.d.ts @@ -104,6 +104,15 @@ type TraderRecoverAccounts = { readonly responseType: typeof trader_pb.RecoverAccountsResponse; }; +type TraderAccountModificationFees = { + readonly methodName: string; + readonly service: typeof Trader; + readonly requestStream: false; + readonly responseStream: false; + readonly requestType: typeof trader_pb.AccountModificationFeesRequest; + readonly responseType: typeof trader_pb.AccountModificationFeesResponse; +}; + type TraderSubmitOrder = { readonly methodName: string; readonly service: typeof Trader; @@ -279,6 +288,7 @@ export class Trader { static readonly RenewAccount: TraderRenewAccount; static readonly BumpAccountFee: TraderBumpAccountFee; static readonly RecoverAccounts: TraderRecoverAccounts; + static readonly AccountModificationFees: TraderAccountModificationFees; static readonly SubmitOrder: TraderSubmitOrder; static readonly ListOrders: TraderListOrders; static readonly CancelOrder: TraderCancelOrder; @@ -430,6 +440,15 @@ export class TraderClient { requestMessage: trader_pb.RecoverAccountsRequest, callback: (error: ServiceError|null, responseMessage: trader_pb.RecoverAccountsResponse|null) => void ): UnaryResponse; + accountModificationFees( + requestMessage: trader_pb.AccountModificationFeesRequest, + metadata: grpc.Metadata, + callback: (error: ServiceError|null, responseMessage: trader_pb.AccountModificationFeesResponse|null) => void + ): UnaryResponse; + accountModificationFees( + requestMessage: trader_pb.AccountModificationFeesRequest, + callback: (error: ServiceError|null, responseMessage: trader_pb.AccountModificationFeesResponse|null) => void + ): UnaryResponse; submitOrder( requestMessage: trader_pb.SubmitOrderRequest, metadata: grpc.Metadata, diff --git a/app/src/types/generated/trader_pb_service.js b/app/src/types/generated/trader_pb_service.js index f9975211..9b1baa9b 100644 --- a/app/src/types/generated/trader_pb_service.js +++ b/app/src/types/generated/trader_pb_service.js @@ -110,6 +110,15 @@ Trader.RecoverAccounts = { responseType: trader_pb.RecoverAccountsResponse }; +Trader.AccountModificationFees = { + methodName: "AccountModificationFees", + service: Trader, + requestStream: false, + responseStream: false, + requestType: trader_pb.AccountModificationFeesRequest, + responseType: trader_pb.AccountModificationFeesResponse +}; + Trader.SubmitOrder = { methodName: "SubmitOrder", service: Trader, @@ -620,6 +629,37 @@ TraderClient.prototype.recoverAccounts = function recoverAccounts(requestMessage }; }; +TraderClient.prototype.accountModificationFees = function accountModificationFees(requestMessage, metadata, callback) { + if (arguments.length === 2) { + callback = arguments[1]; + } + var client = grpc.unary(Trader.AccountModificationFees, { + 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(); + } + }; +}; + TraderClient.prototype.submitOrder = function submitOrder(requestMessage, metadata, callback) { if (arguments.length === 2) { callback = arguments[1]; diff --git a/go.mod b/go.mod index c1869c14..3dbeaf3d 100644 --- a/go.mod +++ b/go.mod @@ -19,7 +19,7 @@ require ( github.com/lightninglabs/lndclient v0.16.0-9 github.com/lightninglabs/loop v0.21.0-beta.0.20230307115451-ec4f2507535c github.com/lightninglabs/loop/swapserverrpc v1.0.3 - github.com/lightninglabs/pool v0.6.1-beta.0.20230227204507-0db3a9fdc6fd + github.com/lightninglabs/pool v0.6.2-beta github.com/lightninglabs/pool/auctioneerrpc v1.1.0 github.com/lightninglabs/protobuf-hex-display v1.4.3-hex-display github.com/lightningnetwork/lnd v0.16.0-beta.rc2 diff --git a/go.sum b/go.sum index b44a4520..3086679b 100644 --- a/go.sum +++ b/go.sum @@ -547,8 +547,8 @@ github.com/lightninglabs/neutrino v0.15.0 h1:yr3uz36fLAq8hyM0TRUVlef1TRNoWAqpmmN github.com/lightninglabs/neutrino v0.15.0/go.mod h1:pmjwElN/091TErtSE9Vd5W4hpxoG2/+xlb+HoPm9Gug= github.com/lightninglabs/neutrino/cache v1.1.1 h1:TllWOSlkABhpgbWJfzsrdUaDH2fBy/54VSIB4vVqV8M= github.com/lightninglabs/neutrino/cache v1.1.1/go.mod h1:XJNcgdOw1LQnanGjw8Vj44CvguYA25IMKjWFZczwZuo= -github.com/lightninglabs/pool v0.6.1-beta.0.20230227204507-0db3a9fdc6fd h1:pbNKLVdWnLXy12Jyf79DUbkA1k/gbG4Qqq4YZyPkc/M= -github.com/lightninglabs/pool v0.6.1-beta.0.20230227204507-0db3a9fdc6fd/go.mod h1:v5VyYxU+mLsBgDoniJv9ylOsIY2E+xaOR/iSNHfTIiM= +github.com/lightninglabs/pool v0.6.2-beta h1:TGO9BB5M829l9HA8b9wny47527IyKuWt2assANI8G78= +github.com/lightninglabs/pool v0.6.2-beta/go.mod h1:3lfQEiEueD8j1SzBv1+zN+0d8Auf1s31raNyXA6asV0= github.com/lightninglabs/pool/auctioneerrpc v1.1.0 h1:XOhmaFKRvQ1smwkY9SRTA0+FCloTExuhaQX4jgtrBB0= github.com/lightninglabs/pool/auctioneerrpc v1.1.0/go.mod h1:F9uND5Kpj2eYeYe0RLi8IWQHsRjQ88FUp8itkYmX1Mo= github.com/lightninglabs/protobuf-hex-display v1.4.3-hex-display h1:RZJ8H4ueU/aQ9pFtx5wqsuD3B/DezrewJeVwDKKYY8E= diff --git a/proto/trader.proto b/proto/trader.proto index 204b6afe..f263c627 100644 --- a/proto/trader.proto +++ b/proto/trader.proto @@ -78,6 +78,13 @@ service Trader { rpc RecoverAccounts (RecoverAccountsRequest) returns (RecoverAccountsResponse); + /* pool: `accounts listfees` + AccountModificationFees returns a map from account key to an ordered list of + account action modification fees. + */ + rpc AccountModificationFees (AccountModificationFeesRequest) + returns (AccountModificationFeesResponse); + /* pool: `orders submit` SubmitOrder creates a new ask or bid order and submits for the given account and submits it to the auction server for matching. @@ -211,7 +218,8 @@ enum AccountVersion { /* Let the version of lnd decide. If a version of lnd >= 0.15.0-beta is detected then a Taproot account is created. For earlier versions a legacy - account is created. + account is created. If a version of lnd >= 0.16.0-beta is detected, then a + Taproot v2 account is created. */ ACCOUNT_VERSION_LND_DEPENDENT = 0; @@ -225,6 +233,14 @@ enum AccountVersion { script as a single tap script leaf. */ ACCOUNT_VERSION_TAPROOT = 2; + + /* + A Taproot enabled account with MuSig2 combined internal key and the expiry + script as a single tap script leaf. This version uses the MuSig2 v1.0.0-rc2 + protocol for creating the combined internal key. This can only be selected + when the connected lnd version is >= 0.16.0-beta. + */ + ACCOUNT_VERSION_TAPROOT_V2 = 3; } message InitAccountRequest { @@ -1011,6 +1027,45 @@ message RecoverAccountsResponse { uint32 num_recovered_accounts = 1; } +message AccountModificationFeesRequest { +} + +message AccountModificationFee { + // Modification action type. + string action = 1; + + // Transaction ID. + string txid = 2; + + // Action transaction block height. + int32 block_height = 3; + + // Action transaction timestamp. + int64 timestamp = 4 [jstype = JS_STRING]; + + // Action transaction output amount. + int64 output_amount = 5 [jstype = JS_STRING]; + + // Action transaction fee. + oneof fee { + // A flag which is true if fee value has not been set, and is otherwise + // false. + bool fee_null = 6; + + // Action transaction fee value. + int64 fee_value = 7 [jstype = JS_STRING]; + } +} + +message ListOfAccountModificationFees { + repeated AccountModificationFee modification_fees = 1; +} + +message AccountModificationFeesResponse { + // A map from account key to an ordered list of account modification fees. + map accounts = 1; +} + message AuctionFeeRequest { }