diff --git a/.github/workflows/golangci.yml b/.github/workflows/golangci.yml index f25f9cc4f..7c9d28e8d 100644 --- a/.github/workflows/golangci.yml +++ b/.github/workflows/golangci.yml @@ -11,9 +11,6 @@ on: - main paths-ignore: - 'web-ui/**' - pull_request: - paths: - - 'icq-relayer/**' permissions: contents: read diff --git a/Makefile b/Makefile index fe89201e2..857218c82 100755 --- a/Makefile +++ b/Makefile @@ -477,7 +477,7 @@ mdlint-fix: ### Protobuf ### ############################################################################### -BUF_VERSION=1.31.0 +BUF_VERSION=1.35.1 proto-all: proto-gen diff --git a/docs/swagger.yml b/docs/swagger.yml index 3bcc8b721..339bc4a0f 100644 --- a/docs/swagger.yml +++ b/docs/swagger.yml @@ -1663,10 +1663,7 @@ paths: protobuf release, and it is not used for type URLs beginning with - type.googleapis.com. As of May 2023, there are no widely - used type server - - implementations and no plans to implement one. + type.googleapis.com. Schemes other than `http`, `https` (or the empty scheme) @@ -1711,10 +1708,6 @@ paths: if (any.is(Foo.class)) { foo = any.unpack(Foo.class); } - // or ... - if (any.isSameTypeAs(Foo.getDefaultInstance())) { - foo = any.unpack(Foo.getDefaultInstance()); - } Example 3: Pack and unpack a message in Python. @@ -1754,6 +1747,7 @@ paths: name "y.z". + JSON ==== @@ -1980,10 +1974,7 @@ paths: protobuf release, and it is not used for type URLs beginning with - type.googleapis.com. As of May 2023, there are no widely - used type server - - implementations and no plans to implement one. + type.googleapis.com. Schemes other than `http`, `https` (or the empty scheme) @@ -2028,10 +2019,6 @@ paths: if (any.is(Foo.class)) { foo = any.unpack(Foo.class); } - // or ... - if (any.isSameTypeAs(Foo.getDefaultInstance())) { - foo = any.unpack(Foo.getDefaultInstance()); - } Example 3: Pack and unpack a message in Python. @@ -2071,6 +2058,7 @@ paths: name "y.z". + JSON ==== @@ -2224,9 +2212,11 @@ paths: - Msg /quicksilver/tx/v1/interchainstaking/cancel_redemption: post: - summary: |- - CancelRedemption defines a method for cancelling a redemption request in - the queued state. + summary: >- + CancelRedemption defines a method for cancelling a redemption request + and + + returning the escrowed assets. operationId: CancelRedemption responses: '200': @@ -2250,7 +2240,7 @@ paths: signatures required by gogoproto. description: >- - MsgRequestRedemptionResponse defines the MsgRequestRedemption + MsgCancelRedemptionResponse defines the MsgCancelRedemption response type. default: description: An unexpected error response. @@ -2287,7 +2277,7 @@ paths: type: string from_address: type: string - description: MsgCancelQueuedRedemption represents a message type to cancel . + description: MsgCancelRedemption represents a message type to cancel . tags: - Msg /quicksilver/tx/v1/interchainstaking/close_channel: @@ -2577,6 +2567,111 @@ paths: type: string tags: - Msg + /quicksilver/tx/v1/interchainstaking/requeue_redemption: + post: + summary: RequeueRedemption defines a method for requeuing a failed redemption. + operationId: RequeueRedemption + responses: + '200': + description: A successful response. + schema: + type: object + description: >- + MsgRequeueRedemptionResponse defines the MsgRequeueRedemption + response type. + default: + description: An unexpected error response. + schema: + type: object + properties: + error: + type: string + code: + type: integer + format: int32 + message: + type: string + details: + type: array + items: + type: object + properties: + type_url: + type: string + value: + type: string + format: byte + parameters: + - name: body + in: body + required: true + schema: + type: object + properties: + chain_id: + type: string + hash: + type: string + from_address: + type: string + description: MsgRequeueRedemption represents a message type to requeue. + tags: + - Msg + /quicksilver/tx/v1/interchainstaking/update_redemption: + post: + summary: UpdateRedemption defines a method for updating a redemption. + operationId: UpdateRedemption + responses: + '200': + description: A successful response. + schema: + type: object + description: >- + MsgUpdateRedemptionResponse defines the MsgUpdateRedemption + response type. + default: + description: An unexpected error response. + schema: + type: object + properties: + error: + type: string + code: + type: integer + format: int32 + message: + type: string + details: + type: array + items: + type: object + properties: + type_url: + type: string + value: + type: string + format: byte + parameters: + - name: body + in: body + required: true + schema: + type: object + properties: + chain_id: + type: string + hash: + type: string + new_status: + type: integer + format: int32 + from_address: + type: string + description: >- + MsgUpdateRedemption represents a message type to update a + redemption. + tags: + - Msg /quicksilver/interchainstaking/v1/claimed_percentage/{chain_id}: get: summary: >- @@ -2964,6 +3059,9 @@ paths: epoch_number: type: string format: int64 + send_errors: + type: string + format: int64 pagination: type: object properties: @@ -3920,6 +4018,9 @@ paths: epoch_number: type: string format: int64 + send_errors: + type: string + format: int64 pagination: type: object properties: @@ -5069,6 +5170,9 @@ paths: epoch_number: type: string format: int64 + send_errors: + type: string + format: int64 pagination: type: object properties: @@ -5267,6 +5371,9 @@ paths: epoch_number: type: string format: int64 + send_errors: + type: string + format: int64 pagination: type: object properties: diff --git a/proto/quicksilver/interchainstaking/v1/interchainstaking.proto b/proto/quicksilver/interchainstaking/v1/interchainstaking.proto index fa26c82c3..e8a762fc4 100644 --- a/proto/quicksilver/interchainstaking/v1/interchainstaking.proto +++ b/proto/quicksilver/interchainstaking/v1/interchainstaking.proto @@ -118,7 +118,7 @@ message WithdrawalRecord { (gogoproto.nullable) = false ]; string txhash = 7; - int32 status = 8; + int32 status = 8; // should be an enum! google.protobuf.Timestamp completion_time = 9 [ (gogoproto.nullable) = false, (gogoproto.stdtime) = true @@ -126,6 +126,7 @@ message WithdrawalRecord { bool requeued = 10; bool acknowledged = 11; int64 epoch_number = 12; + int64 send_errors = 13; } message UnbondingRecord { diff --git a/proto/quicksilver/interchainstaking/v1/messages.proto b/proto/quicksilver/interchainstaking/v1/messages.proto index 8a13c3c57..fa4b40edf 100644 --- a/proto/quicksilver/interchainstaking/v1/messages.proto +++ b/proto/quicksilver/interchainstaking/v1/messages.proto @@ -28,15 +28,31 @@ service Msg { }; } - // CancelRedemption defines a method for cancelling a redemption request in - // the queued state. - rpc CancelRedemption(MsgCancelQueuedRedemption) returns (MsgCancelQueuedRedemptionResponse) { + // CancelRedemption defines a method for cancelling a redemption request and + // returning the escrowed assets. + rpc CancelRedemption(MsgCancelRedemption) returns (MsgCancelRedemptionResponse) { option (google.api.http) = { post: "/quicksilver/tx/v1/interchainstaking/cancel_redemption" body: "*" }; } + // RequeueRedemption defines a method for requeuing a failed redemption. + rpc RequeueRedemption(MsgRequeueRedemption) returns (MsgRequeueRedemptionResponse) { + option (google.api.http) = { + post: "/quicksilver/tx/v1/interchainstaking/requeue_redemption" + body: "*" + }; + } + + // UpdateRedemption defines a method for updating a redemption. + rpc UpdateRedemption(MsgUpdateRedemption) returns (MsgUpdateRedemptionResponse) { + option (google.api.http) = { + post: "/quicksilver/tx/v1/interchainstaking/update_redemption" + body: "*" + }; + } + // SignalIntent defines a method for signalling voting intent for one or more // validators. rpc GovCloseChannel(MsgGovCloseChannel) returns (MsgGovCloseChannelResponse) { @@ -92,8 +108,8 @@ message MsgRequestRedemption { // MsgRequestRedemptionResponse defines the MsgRequestRedemption response type. message MsgRequestRedemptionResponse {} -// MsgCancelQueuedRedemption represents a message type to cancel . -message MsgCancelQueuedRedemption { +// MsgCancelRedemption represents a message type to cancel . +message MsgCancelRedemption { option (gogoproto.equal) = false; option (gogoproto.goproto_getters) = false; @@ -102,14 +118,41 @@ message MsgCancelQueuedRedemption { string from_address = 3 [(cosmos_proto.scalar) = "cosmos.AddressString"]; } -// MsgRequestRedemptionResponse defines the MsgRequestRedemption response type. -message MsgCancelQueuedRedemptionResponse { +// MsgCancelRedemptionResponse defines the MsgCancelRedemption response type. +message MsgCancelRedemptionResponse { cosmos.base.v1beta1.Coin returned = 1 [ (gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"coin\"" ]; } +// MsgUpdateRedemption represents a message type to update a redemption. +message MsgUpdateRedemption { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string chain_id = 1; + string hash = 2; + int32 new_status = 3; + string from_address = 4 [(cosmos_proto.scalar) = "cosmos.AddressString"]; +} + +// MsgUpdateRedemptionResponse defines the MsgUpdateRedemption response type. +message MsgUpdateRedemptionResponse {} + +// MsgRequeueRedemption represents a message type to requeue. +message MsgRequeueRedemption { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string chain_id = 1; + string hash = 2; + string from_address = 3 [(cosmos_proto.scalar) = "cosmos.AddressString"]; +} + +// MsgRequeueRedemptionResponse defines the MsgRequeueRedemption response type. +message MsgRequeueRedemptionResponse {} + // MsgSignalIntent represents a message type for signalling voting intent for // one or more validators. message MsgSignalIntent { diff --git a/x/airdrop/types/messages.pb.go b/x/airdrop/types/messages.pb.go index 3509cf722..32aa7f26b 100644 --- a/x/airdrop/types/messages.pb.go +++ b/x/airdrop/types/messages.pb.go @@ -202,50 +202,50 @@ func init() { } var fileDescriptor_2b0828c7de1949a1 = []byte{ - // 684 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x54, 0xbd, 0x6f, 0xd3, 0x4e, - 0x18, 0x8e, 0x93, 0xf4, 0xeb, 0xaa, 0xdf, 0x07, 0xa6, 0x94, 0x34, 0x02, 0x3b, 0x32, 0xaa, 0x14, - 0x8a, 0x62, 0x37, 0xe5, 0xa3, 0x52, 0x36, 0x52, 0x96, 0x0e, 0x45, 0x25, 0xdd, 0x58, 0xa2, 0x8b, - 0x7d, 0xb8, 0xa7, 0xda, 0xf7, 0x1a, 0xdf, 0x25, 0x6a, 0x99, 0x50, 0x25, 0x24, 0x46, 0x24, 0xfe, - 0x81, 0xce, 0x4c, 0x0c, 0x88, 0x8d, 0x81, 0xad, 0x63, 0x05, 0x0b, 0x53, 0x40, 0x2d, 0x12, 0xcc, - 0xfd, 0x0b, 0x90, 0xcf, 0xe7, 0xd6, 0x11, 0xa5, 0x15, 0x93, 0xef, 0xde, 0xf7, 0x79, 0xbf, 0x9e, - 0xf7, 0x39, 0xa3, 0xf9, 0xa7, 0x7d, 0xea, 0x6e, 0x71, 0x1a, 0x0c, 0x48, 0xec, 0x60, 0x1a, 0x7b, - 0x31, 0x44, 0xce, 0xa0, 0xe9, 0x84, 0x84, 0x73, 0xec, 0x13, 0x6e, 0x47, 0x31, 0x08, 0xd0, 0x67, - 0x73, 0x30, 0x5b, 0xc1, 0xec, 0x41, 0xb3, 0x6a, 0xb8, 0xc0, 0x43, 0xe0, 0x4e, 0x0f, 0x73, 0xe2, - 0x0c, 0x9a, 0x3d, 0x22, 0x70, 0xd3, 0x71, 0x81, 0xb2, 0x34, 0xae, 0x7a, 0x55, 0xf9, 0x43, 0xee, - 0xcb, 0xac, 0xdc, 0x57, 0x8e, 0xb9, 0xd4, 0xd1, 0x95, 0x37, 0x27, 0xbd, 0x28, 0xd7, 0x8c, 0x0f, - 0x3e, 0xa4, 0xf6, 0xe4, 0xa4, 0xac, 0xd7, 0x7c, 0x00, 0x3f, 0x20, 0x0e, 0x8e, 0xa8, 0x83, 0x19, - 0x03, 0x81, 0x05, 0x05, 0x96, 0xc5, 0x2c, 0xe6, 0xc7, 0x70, 0x03, 0x4c, 0x43, 0x1e, 0x62, 0x86, - 0x7d, 0x12, 0x27, 0x65, 0x47, 0x0c, 0x69, 0x84, 0xf5, 0xa2, 0x88, 0x26, 0xd7, 0xb8, 0xbf, 0x92, - 0xb8, 0x74, 0x1b, 0x4d, 0xba, 0x9b, 0x98, 0xb2, 0x2e, 0xf5, 0x2a, 0x5a, 0x4d, 0xab, 0x4f, 0xb5, - 0x2f, 0x1f, 0x0f, 0xcd, 0xff, 0x76, 0x70, 0x18, 0xb4, 0xac, 0xcc, 0x63, 0x75, 0x26, 0xe4, 0x71, - 0xd5, 0xd3, 0x6f, 0xa2, 0x71, 0xec, 0x26, 0xf5, 0x2b, 0xc5, 0x9a, 0x56, 0x2f, 0xb5, 0x2f, 0x1d, - 0x0f, 0xcd, 0x7f, 0x52, 0x74, 0x6a, 0xb7, 0x3a, 0x0a, 0xa0, 0x3f, 0x40, 0x13, 0xd8, 0xf3, 0x62, - 0xc2, 0x79, 0xa5, 0x24, 0x33, 0x2f, 0x1c, 0x0f, 0xcd, 0x7f, 0x15, 0x36, 0x75, 0x58, 0x9f, 0xde, - 0x35, 0x66, 0x14, 0x05, 0xf7, 0x53, 0xd3, 0x86, 0x88, 0x29, 0xf3, 0x3b, 0x59, 0xa8, 0xfe, 0x10, - 0x8d, 0x47, 0x31, 0xc0, 0x13, 0x5e, 0x29, 0xd7, 0x4a, 0xf5, 0xe9, 0xa5, 0x1b, 0x76, 0x7e, 0x21, - 0xa3, 0xf3, 0x0d, 0x9a, 0xf6, 0x7a, 0x82, 0xcd, 0x77, 0x95, 0x06, 0x5b, 0x1d, 0x95, 0xa5, 0x35, - 0xf9, 0x72, 0xcf, 0x2c, 0xfc, 0xdc, 0x33, 0x0b, 0xd6, 0x0a, 0xfa, 0x3f, 0xa3, 0xa1, 0x43, 0x78, - 0x04, 0x8c, 0x13, 0x39, 0x5e, 0x08, 0x7d, 0x26, 0x24, 0x19, 0xe5, 0x91, 0xf1, 0xa4, 0x3d, 0x19, - 0x4f, 0x1e, 0x5a, 0xe5, 0x24, 0x91, 0xf5, 0xa1, 0x88, 0xae, 0xac, 0x71, 0x7f, 0x95, 0xb9, 0x84, - 0x09, 0x3a, 0x20, 0xeb, 0x00, 0xc1, 0x46, 0x44, 0x98, 0xa7, 0xdf, 0x43, 0x53, 0xb8, 0x2f, 0x36, - 0x21, 0xa6, 0x62, 0x47, 0x51, 0x5b, 0xf9, 0xe3, 0xb8, 0xa7, 0x50, 0x7d, 0x19, 0x21, 0x01, 0xdd, - 0x8c, 0xb9, 0xe2, 0x45, 0x81, 0x02, 0x94, 0x41, 0x77, 0x4f, 0x7a, 0x2f, 0x49, 0xa6, 0xe6, 0x6c, - 0x15, 0x91, 0x48, 0xd4, 0x56, 0x12, 0xb5, 0x57, 0x80, 0xb2, 0xf6, 0xe2, 0xfe, 0xd0, 0x2c, 0xbc, - 0xf9, 0x6a, 0xd6, 0x7d, 0x2a, 0x36, 0xfb, 0x3d, 0xdb, 0x85, 0x50, 0x29, 0x51, 0x7d, 0x1a, 0xdc, - 0xdb, 0x72, 0xc4, 0x4e, 0x44, 0xb8, 0x0c, 0xe0, 0xd9, 0xd4, 0xfa, 0x0c, 0x1a, 0x13, 0x54, 0x04, - 0xa4, 0x52, 0x4e, 0x1a, 0xeb, 0xa4, 0x17, 0xbd, 0x86, 0xa6, 0x3d, 0xc2, 0xdd, 0x98, 0x46, 0x52, - 0x1a, 0x63, 0xd2, 0x97, 0x37, 0xb5, 0x66, 0x33, 0xda, 0x77, 0x7f, 0xbc, 0x5d, 0x38, 0x9d, 0xd6, - 0x32, 0xd1, 0xf5, 0x33, 0xe9, 0xcb, 0x36, 0xb2, 0xf4, 0xb1, 0x88, 0x4a, 0x6b, 0xdc, 0xd7, 0x9f, - 0x6b, 0x68, 0x2c, 0x95, 0x6c, 0xcd, 0x3e, 0xfb, 0x49, 0xda, 0xd9, 0x36, 0xab, 0xf5, 0x8b, 0x10, - 0x59, 0x76, 0xeb, 0xd6, 0xee, 0xe7, 0xef, 0xaf, 0x8b, 0xf3, 0x2d, 0x6d, 0xc1, 0xaa, 0x39, 0xf9, - 0x97, 0x24, 0xb6, 0x93, 0xe7, 0x93, 0xfd, 0x16, 0xa4, 0xcc, 0xf4, 0xf7, 0x1a, 0xd2, 0xcf, 0x58, - 0x74, 0xe3, 0x9c, 0x6a, 0xbf, 0xc3, 0xab, 0x77, 0xff, 0x0a, 0x7e, 0xd2, 0x69, 0x4b, 0x76, 0x7a, - 0x27, 0xe9, 0xd4, 0x39, 0xa7, 0x53, 0x9a, 0x65, 0xe8, 0x46, 0x00, 0x41, 0x97, 0x27, 0x39, 0xda, - 0x8f, 0xf6, 0x0f, 0x0d, 0xed, 0xe0, 0xd0, 0xd0, 0xbe, 0x1d, 0x1a, 0xda, 0xab, 0x23, 0xa3, 0x70, - 0x70, 0x64, 0x14, 0xbe, 0x1c, 0x19, 0x85, 0xc7, 0xcb, 0x39, 0x01, 0xe4, 0x92, 0x36, 0x9e, 0x01, - 0x23, 0x23, 0x55, 0xb6, 0x4f, 0x2a, 0x48, 0x55, 0xf4, 0xc6, 0xe5, 0xbf, 0xe4, 0xf6, 0xaf, 0x00, - 0x00, 0x00, 0xff, 0xff, 0x39, 0xec, 0x3d, 0x88, 0x46, 0x05, 0x00, 0x00, + // 683 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x54, 0x3d, 0x6f, 0xd3, 0x40, + 0x18, 0x8e, 0x93, 0xf4, 0xeb, 0x2a, 0xbe, 0x4c, 0x29, 0x69, 0x04, 0x76, 0x64, 0x54, 0x29, 0x04, + 0xc5, 0x6e, 0xca, 0x47, 0x25, 0x6f, 0xa4, 0x2c, 0x1d, 0x8a, 0x4a, 0xba, 0xb1, 0x44, 0x17, 0xfb, + 0xb8, 0x9e, 0x6a, 0xdf, 0x19, 0xdf, 0x25, 0x6a, 0x99, 0x50, 0x25, 0x24, 0x46, 0x24, 0xfe, 0x40, + 0x67, 0x26, 0x06, 0xc4, 0xc6, 0xc0, 0xd6, 0xb1, 0x82, 0x85, 0x29, 0xa0, 0x16, 0x09, 0xe6, 0xfe, + 0x02, 0xe4, 0xf3, 0xb9, 0x75, 0x44, 0x69, 0xc5, 0xe4, 0xbb, 0xf7, 0x7d, 0x9e, 0xf7, 0xf3, 0x39, + 0x83, 0xf9, 0xe7, 0x7d, 0xe2, 0x6d, 0x72, 0x12, 0x0c, 0x50, 0xec, 0x40, 0x12, 0xfb, 0x31, 0x8b, + 0x9c, 0x41, 0xcb, 0x09, 0x11, 0xe7, 0x10, 0x23, 0x6e, 0x47, 0x31, 0x13, 0x4c, 0x9f, 0xcd, 0xc1, + 0x6c, 0x05, 0xb3, 0x07, 0xad, 0xaa, 0xe1, 0x31, 0x1e, 0x32, 0xee, 0xf4, 0x20, 0x47, 0xce, 0xa0, + 0xd5, 0x43, 0x02, 0xb6, 0x1c, 0x8f, 0x11, 0x9a, 0xf2, 0xaa, 0xd7, 0x95, 0x3f, 0xe4, 0x58, 0x46, + 0xe5, 0x58, 0x39, 0xe6, 0x52, 0x47, 0x57, 0xde, 0x9c, 0xf4, 0xa2, 0x5c, 0x33, 0x98, 0x61, 0x96, + 0xda, 0x93, 0x93, 0xb2, 0xde, 0xc0, 0x8c, 0xe1, 0x00, 0x39, 0x30, 0x22, 0x0e, 0xa4, 0x94, 0x09, + 0x28, 0x08, 0xa3, 0x19, 0x67, 0x21, 0xdf, 0x86, 0x17, 0x40, 0x12, 0xf2, 0x10, 0x52, 0x88, 0x51, + 0x9c, 0xa4, 0x1d, 0x31, 0xa4, 0x0c, 0xeb, 0x55, 0x11, 0x4c, 0xae, 0x72, 0xbc, 0x9c, 0xb8, 0x74, + 0x1b, 0x4c, 0x7a, 0x1b, 0x90, 0xd0, 0x2e, 0xf1, 0x2b, 0x5a, 0x4d, 0xab, 0x4f, 0xb5, 0xaf, 0x1e, + 0x0d, 0xcd, 0x4b, 0xdb, 0x30, 0x0c, 0x5c, 0x2b, 0xf3, 0x58, 0x9d, 0x09, 0x79, 0x5c, 0xf1, 0xf5, + 0xdb, 0x60, 0x1c, 0x7a, 0x49, 0xfe, 0x4a, 0xb1, 0xa6, 0xd5, 0x4b, 0xed, 0x2b, 0x47, 0x43, 0xf3, + 0x42, 0x8a, 0x4e, 0xed, 0x56, 0x47, 0x01, 0xf4, 0x47, 0x60, 0x02, 0xfa, 0x7e, 0x8c, 0x38, 0xaf, + 0x94, 0x64, 0xe4, 0xc6, 0xd1, 0xd0, 0xbc, 0xa8, 0xb0, 0xa9, 0xc3, 0xfa, 0xf2, 0xa1, 0x39, 0xa3, + 0x46, 0xf0, 0x30, 0x35, 0xad, 0x8b, 0x98, 0x50, 0xdc, 0xc9, 0xa8, 0xfa, 0x63, 0x30, 0x1e, 0xc5, + 0x8c, 0x3d, 0xe3, 0x95, 0x72, 0xad, 0x54, 0x9f, 0x5e, 0xbc, 0x65, 0xe7, 0x17, 0x32, 0xda, 0xdf, + 0xa0, 0x65, 0xaf, 0x25, 0xd8, 0x7c, 0x55, 0x29, 0xd9, 0xea, 0xa8, 0x28, 0xee, 0xe4, 0xeb, 0x5d, + 0xb3, 0xf0, 0x7b, 0xd7, 0x2c, 0x58, 0xcb, 0xe0, 0x72, 0x36, 0x86, 0x0e, 0xe2, 0x11, 0xa3, 0x1c, + 0xc9, 0xf6, 0x42, 0xd6, 0xa7, 0x42, 0x0e, 0xa3, 0x3c, 0xd2, 0x9e, 0xb4, 0x27, 0xed, 0xc9, 0x83, + 0x5b, 0x4e, 0x02, 0x59, 0x9f, 0x8a, 0xe0, 0xda, 0x2a, 0xc7, 0x2b, 0xd4, 0x43, 0x54, 0x90, 0x01, + 0x5a, 0x63, 0x2c, 0x58, 0x8f, 0x10, 0xf5, 0xf5, 0x07, 0x60, 0x0a, 0xf6, 0xc5, 0x06, 0x8b, 0x89, + 0xd8, 0x56, 0xa3, 0xad, 0xfc, 0xb3, 0xdd, 0x13, 0xa8, 0xbe, 0x04, 0x80, 0x60, 0xdd, 0x6c, 0x72, + 0xc5, 0xf3, 0x88, 0x82, 0x29, 0x83, 0xee, 0x1d, 0xd7, 0x5e, 0x92, 0x93, 0x9a, 0xb3, 0x15, 0x23, + 0x91, 0xa8, 0xad, 0x24, 0x6a, 0x2f, 0x33, 0x42, 0xdb, 0x0b, 0x7b, 0x43, 0xb3, 0xf0, 0xee, 0xbb, + 0x59, 0xc7, 0x44, 0x6c, 0xf4, 0x7b, 0xb6, 0xc7, 0x42, 0xa5, 0x44, 0xf5, 0x69, 0x72, 0x7f, 0xd3, + 0x11, 0xdb, 0x11, 0xe2, 0x92, 0xc0, 0xb3, 0xae, 0xf5, 0x19, 0x30, 0x26, 0x88, 0x08, 0x50, 0xa5, + 0x9c, 0x14, 0xd6, 0x49, 0x2f, 0x7a, 0x0d, 0x4c, 0xfb, 0x88, 0x7b, 0x31, 0x89, 0xa4, 0x34, 0xc6, + 0xa4, 0x2f, 0x6f, 0x72, 0x67, 0xb3, 0xb1, 0xef, 0xfc, 0x7a, 0xdf, 0x38, 0xe9, 0xd6, 0x32, 0xc1, + 0xcd, 0x53, 0xc7, 0x97, 0x6d, 0x64, 0xf1, 0x73, 0x11, 0x94, 0x56, 0x39, 0xd6, 0x5f, 0x6a, 0x60, + 0x2c, 0x95, 0x6c, 0xcd, 0x3e, 0xfd, 0x49, 0xda, 0xd9, 0x36, 0xab, 0xf5, 0xf3, 0x10, 0x59, 0x74, + 0xeb, 0xce, 0xce, 0xd7, 0x9f, 0x6f, 0x8b, 0xf3, 0x56, 0xcd, 0xc9, 0x3f, 0x23, 0xb1, 0x95, 0xbc, + 0x9d, 0xec, 0x9f, 0x20, 0x35, 0xe6, 0x6a, 0x0d, 0xfd, 0xa3, 0x06, 0xf4, 0x53, 0x16, 0xdd, 0x3c, + 0x23, 0xdb, 0xdf, 0xf0, 0xea, 0xfd, 0xff, 0x82, 0x1f, 0x57, 0xea, 0xca, 0x4a, 0xef, 0x59, 0xce, + 0x19, 0x95, 0x92, 0x8c, 0xde, 0x8d, 0x18, 0x0b, 0xba, 0x3c, 0x09, 0xe0, 0x6a, 0x8d, 0xf6, 0x93, + 0xbd, 0x03, 0x43, 0xdb, 0x3f, 0x30, 0xb4, 0x1f, 0x07, 0x86, 0xf6, 0xe6, 0xd0, 0x28, 0xec, 0x1f, + 0x1a, 0x85, 0x6f, 0x87, 0x46, 0xe1, 0xe9, 0x52, 0x4e, 0x00, 0xb9, 0xb8, 0xcd, 0x17, 0x8c, 0xa2, + 0x91, 0x44, 0x5b, 0xc7, 0x49, 0xa4, 0x2a, 0x7a, 0xe3, 0xf2, 0x5f, 0x72, 0xf7, 0x4f, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x8d, 0x34, 0xd3, 0x8b, 0x46, 0x05, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. diff --git a/x/interchainquery/types/messages.pb.go b/x/interchainquery/types/messages.pb.go index 1b170fce0..5723a80ef 100644 --- a/x/interchainquery/types/messages.pb.go +++ b/x/interchainquery/types/messages.pb.go @@ -149,12 +149,12 @@ var fileDescriptor_0640fcbc3e895a79 = []byte{ 0x82, 0x9d, 0x94, 0xce, 0xa4, 0x76, 0xf9, 0xcd, 0xd4, 0x2b, 0xbc, 0x9f, 0x7a, 0xe0, 0xe7, 0xd4, 0x2b, 0xf8, 0x35, 0xcb, 0x5d, 0xff, 0xab, 0xf3, 0xb3, 0xf5, 0x19, 0x58, 0xc5, 0x7d, 0x49, 0xec, 0x8f, 0xc0, 0xda, 0x5d, 0xf7, 0x24, 0xf7, 0xe0, 0xbf, 0x97, 0x07, 0xae, 0xcf, 0x5f, 0x7d, 0xf0, - 0x7f, 0x71, 0xf9, 0xe9, 0xb7, 0x5e, 0x7f, 0xfd, 0xf1, 0x6e, 0xe3, 0x4e, 0x1b, 0xdc, 0xf6, 0x6f, - 0x9e, 0x59, 0x71, 0x75, 0x8c, 0xc6, 0xcd, 0x1e, 0x56, 0x61, 0x13, 0x49, 0x9d, 0x43, 0xcb, 0x9d, + 0x7f, 0x71, 0xf9, 0xe9, 0xb7, 0x5e, 0x7f, 0xfd, 0xf1, 0x6e, 0xe3, 0x8e, 0x7f, 0xf3, 0xcc, 0x7e, + 0xab, 0x63, 0x34, 0x6e, 0xf6, 0xb0, 0x0a, 0x9b, 0x48, 0xea, 0x04, 0x5a, 0x6e, 0x83, 0xdb, 0x9d, 0xe7, 0x9f, 0xe6, 0x2e, 0x38, 0x99, 0xbb, 0xe0, 0xfb, 0xdc, 0x05, 0x6f, 0x17, 0x6e, 0xe1, 0x64, 0xe1, 0x16, 0xbe, 0x2d, 0xdc, 0xc2, 0x8b, 0x87, 0x84, 0xaa, 0xc1, 0xa8, 0x07, 0xfb, 0x3c, 0x46, - 0x2b, 0x7d, 0x35, 0x5e, 0x71, 0x86, 0x57, 0x05, 0x74, 0x7c, 0xb6, 0xd6, 0x24, 0xc1, 0xb2, 0x57, - 0xd2, 0xbb, 0x7b, 0xf7, 0x77, 0x00, 0x00, 0x00, 0xff, 0xff, 0xa3, 0xc4, 0x93, 0xfb, 0x7a, 0x03, + 0x2b, 0x7d, 0x35, 0x5e, 0x71, 0x86, 0x57, 0x05, 0x74, 0x7c, 0xb6, 0xdc, 0x24, 0xc1, 0xb2, 0x57, + 0xd2, 0xbb, 0x7b, 0xf7, 0x77, 0x00, 0x00, 0x00, 0xff, 0xff, 0x4a, 0xd0, 0x97, 0x34, 0x7a, 0x03, 0x00, 0x00, } diff --git a/x/interchainstaking/client/cli/tx.go b/x/interchainstaking/client/cli/tx.go index 7d962552a..feef2ea0c 100644 --- a/x/interchainstaking/client/cli/tx.go +++ b/x/interchainstaking/client/cli/tx.go @@ -33,6 +33,8 @@ func GetTxCmd() *cobra.Command { txCmd.AddCommand(GetSignalIntentTxCmd()) txCmd.AddCommand(GetRequestRedemptionTxCmd()) txCmd.AddCommand(GetReopenChannelTxCmd()) + txCmd.AddCommand(GetCancelUnbondingTxCmd()) + txCmd.AddCommand(GetRequeueUnbondingTxCmd()) return txCmd } @@ -66,6 +68,58 @@ e.g. "0.3cosmosvaloper1xxxxxxxxx,0.3cosmosvaloper1yyyyyyyyy,0.4cosmosvaloper1zzz return cmd } +// GetCancelUnbondingTxCmd returns a CLI command handler for cancelling a queued or failed withdrawal. +func GetCancelUnbondingTxCmd() *cobra.Command { + cmd := &cobra.Command{ + Use: "cancel-redemption [chainID] [hash]", + Short: `Cancel queued or failed withdrawal.`, + Long: `Cancel queued or failed withdrawal and return qAssets to the originating user"`, + Example: `cancel-redemption [chainID] [hash]`, + Args: cobra.ExactArgs(2), + RunE: func(cmd *cobra.Command, args []string) error { + clientCtx, err := client.GetClientTxContext(cmd) + if err != nil { + return err + } + + chainID := args[0] + + msg := types.NewMsgCancelRedemption(chainID, args[1], clientCtx.GetFromAddress()) + + return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg) + }, + } + flags.AddTxFlagsToCmd(cmd) + + return cmd +} + +// GetRequeueUnbondingTxCmd returns a CLI command handler for requeuing a failed withdrawal. +func GetRequeueUnbondingTxCmd() *cobra.Command { + cmd := &cobra.Command{ + Use: "requeue-redemption [chainID] [hash]", + Short: `Requeue a failed withdrawal.`, + Long: `Requeue a failed withdrawal"`, + Example: `requeue-redemption [chainID] [hash]`, + Args: cobra.ExactArgs(2), + RunE: func(cmd *cobra.Command, args []string) error { + clientCtx, err := client.GetClientTxContext(cmd) + if err != nil { + return err + } + + chainID := args[0] + + msg := types.NewMsgRequeueRedemption(chainID, args[1], clientCtx.GetFromAddress()) + + return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg) + }, + } + flags.AddTxFlagsToCmd(cmd) + + return cmd +} + // GetRequestRedemptionTxCmd returns a CLI command handler for creating a Request transaction. func GetRequestRedemptionTxCmd() *cobra.Command { cmd := &cobra.Command{ diff --git a/x/interchainstaking/keeper/ibc_packet_handlers.go b/x/interchainstaking/keeper/ibc_packet_handlers.go index 8f4224f6d..0bf474767 100644 --- a/x/interchainstaking/keeper/ibc_packet_handlers.go +++ b/x/interchainstaking/keeper/ibc_packet_handlers.go @@ -879,6 +879,8 @@ func (k *Keeper) HandleFailedUnbondSend(ctx sdk.Context, sendMsg *banktypes.MsgS // update delayed record with status wdr.DelayCompletion(ctx, types.DefaultWithdrawalRequeueDelay) + // incremement send errors + wdr.SendErrors++ k.UpdateWithdrawalRecordStatus(ctx, &wdr, types.WithdrawStatusUnbond) return nil diff --git a/x/interchainstaking/keeper/msg_server.go b/x/interchainstaking/keeper/msg_server.go index 79b0ec554..8dd6912f1 100644 --- a/x/interchainstaking/keeper/msg_server.go +++ b/x/interchainstaking/keeper/msg_server.go @@ -8,6 +8,7 @@ import ( "errors" "fmt" "strings" + "time" sdk "github.com/cosmos/cosmos-sdk/types" govtypes "github.com/cosmos/cosmos-sdk/x/gov/types" @@ -88,16 +89,23 @@ func (k msgServer) RequestRedemption(goCtx context.Context, msg *types.MsgReques return &types.MsgRequestRedemptionResponse{}, nil } -func (k msgServer) CancelRedemption(goCtx context.Context, msg *types.MsgCancelQueuedRedemption) (*types.MsgCancelQueuedRedemptionResponse, error) { +func (k msgServer) CancelRedemption(goCtx context.Context, msg *types.MsgCancelRedemption) (*types.MsgCancelRedemptionResponse, error) { ctx := sdk.UnwrapSDKContext(goCtx) record, found := k.GetWithdrawalRecord(ctx, msg.ChainId, msg.Hash, types.WithdrawStatusQueued) - + // QUEUED records can be cancelled at any time. if !found { - return nil, fmt.Errorf("no queued record with hash \"%s\" found", msg.Hash) + // check for errored unbond in UNBONDING status + record, found = k.GetWithdrawalRecord(ctx, msg.ChainId, msg.Hash, types.WithdrawStatusUnbond) + if !found { + return nil, fmt.Errorf("no queued record with hash \"%s\" found", msg.Hash) + } + if record.SendErrors == 0 { + return nil, fmt.Errorf("cannot cancel unbond \"%s\" with no errors", msg.Hash) + } } - if record.Delegator != msg.FromAddress { + if record.Delegator != msg.FromAddress && k.Keeper.GetGovAuthority(ctx) != msg.FromAddress { return nil, fmt.Errorf("incorrect user for record with hash \"%s\"", msg.Hash) } @@ -122,12 +130,112 @@ func (k msgServer) CancelRedemption(goCtx context.Context, msg *types.MsgCancelQ sdk.NewEvent( types.EventTypeRedemptionCancellation, sdk.NewAttribute(types.AttributeKeyReturnedAmount, record.BurnAmount.String()), - sdk.NewAttribute(types.AttributeKeyUser, msg.FromAddress), + sdk.NewAttribute(types.AttributeKeyUser, record.Delegator), + sdk.NewAttribute(types.AttributeKeyHash, msg.Hash), + sdk.NewAttribute(types.AttributeKeyChainID, msg.ChainId), + ), + }) + + return &types.MsgCancelRedemptionResponse{Returned: record.BurnAmount}, nil +} + +func (k msgServer) RequeueRedemption(goCtx context.Context, msg *types.MsgRequeueRedemption) (*types.MsgRequeueRedemptionResponse, error) { + ctx := sdk.UnwrapSDKContext(goCtx) + + // check for errored unbond in UNBONDING status + record, found := k.GetWithdrawalRecord(ctx, msg.ChainId, msg.Hash, types.WithdrawStatusUnbond) + if !found { + return nil, fmt.Errorf("no unbonding record with hash \"%s\" found", msg.Hash) + } + if record.SendErrors == 0 { + return nil, fmt.Errorf("cannot requeue unbond \"%s\" with no errors", msg.Hash) + } + + if record.Delegator != msg.FromAddress && k.Keeper.GetGovAuthority(ctx) != msg.FromAddress { + return nil, fmt.Errorf("incorrect user for record with hash \"%s\"", msg.Hash) + } + + // all good. update sendErrors to zero, nil the distributions and amount (as this we be recalculated when processed), and update the state to queued. + record.SendErrors = 0 + record.Amount = nil + record.Distribution = nil + record.CompletionTime = time.Time{} + k.UpdateWithdrawalRecordStatus(ctx, &record, types.WithdrawStatusQueued) + + ctx.EventManager().EmitEvents(sdk.Events{ + sdk.NewEvent( + sdk.EventTypeMessage, + sdk.NewAttribute(sdk.AttributeKeyModule, types.AttributeValueCategory), + ), + sdk.NewEvent( + types.EventTypeRedemptionRequeue, + sdk.NewAttribute(types.AttributeKeyUser, record.Delegator), + sdk.NewAttribute(types.AttributeKeyHash, msg.Hash), + sdk.NewAttribute(types.AttributeKeyChainID, msg.ChainId), + ), + }) + + return &types.MsgRequeueRedemptionResponse{}, nil +} + +func (k msgServer) UpdateRedemption(goCtx context.Context, msg *types.MsgUpdateRedemption) (*types.MsgUpdateRedemptionResponse, error) { + ctx := sdk.UnwrapSDKContext(goCtx) + + if k.Keeper.GetGovAuthority(ctx) != msg.FromAddress { + return nil, fmt.Errorf("MsgUpdateRedemption may only be executed by the gov authority") + } + + switch msg.NewStatus { + case types.WithdrawStatusTokenize: // intentionally removed as not currently supported, but included here for completeness. + return nil, fmt.Errorf("new status WithdrawStatusTokenize not supported") + case types.WithdrawStatusQueued: + case types.WithdrawStatusUnbond: + case types.WithdrawStatusSend: // send is not a valid state for recovery, included here for completeness. + return nil, fmt.Errorf("new status WithdrawStatusSend not supported") + case types.WithdrawStatusCompleted: + default: + return nil, fmt.Errorf("new status not provided or invalid") + } + + var r *types.WithdrawalRecord + + k.IteratePrefixedWithdrawalRecords(ctx, []byte(msg.ChainId), func(index int64, record types.WithdrawalRecord) (stop bool) { + if record.Txhash == msg.Hash { + r = &record + return true + } + return false + }) + + if r == nil { + return nil, fmt.Errorf("no unbonding record with hash \"%s\" found", msg.Hash) + } + + if msg.NewStatus == types.WithdrawStatusQueued { + // update sendErrors to zero, nil the distributions and amount (as this we be recalculated when processed), and update the state to queued. + r.SendErrors = 0 + r.Amount = nil + r.Distribution = nil + r.CompletionTime = time.Time{} + } + + k.UpdateWithdrawalRecordStatus(ctx, r, msg.NewStatus) + + ctx.EventManager().EmitEvents(sdk.Events{ + sdk.NewEvent( + sdk.EventTypeMessage, + sdk.NewAttribute(sdk.AttributeKeyModule, types.AttributeValueCategory), + ), + sdk.NewEvent( + types.EventTypeRedemptionRequeue, + sdk.NewAttribute(types.AttributeKeyUser, r.Delegator), + sdk.NewAttribute(types.AttributeKeyHash, msg.Hash), + sdk.NewAttribute(types.AttributeKeyNewStatus, string(msg.NewStatus)), sdk.NewAttribute(types.AttributeKeyChainID, msg.ChainId), ), }) - return &types.MsgCancelQueuedRedemptionResponse{Returned: record.BurnAmount}, nil + return &types.MsgUpdateRedemptionResponse{}, nil } func (k msgServer) SignalIntent(goCtx context.Context, msg *types.MsgSignalIntent) (*types.MsgSignalIntentResponse, error) { diff --git a/x/interchainstaking/keeper/msg_server_test.go b/x/interchainstaking/keeper/msg_server_test.go index 006f32f3f..e73cd65ae 100644 --- a/x/interchainstaking/keeper/msg_server_test.go +++ b/x/interchainstaking/keeper/msg_server_test.go @@ -801,17 +801,17 @@ func (suite *KeeperTestSuite) TestSetLsmCaps() { } } -func (suite *KeeperTestSuite) TestMsgCancelQueuedRedemeption() { - hash := randomutils.GenerateRandomHashAsHex(64) +func (suite *KeeperTestSuite) TestMsgCancelRedemeption() { + hash := randomutils.GenerateRandomHashAsHex(32) tests := []struct { name string - malleate func(s *KeeperTestSuite) *icstypes.MsgCancelQueuedRedemption + malleate func(s *KeeperTestSuite) *icstypes.MsgCancelRedemption expectErr string }{ { "no zone exists", - func(s *KeeperTestSuite) *icstypes.MsgCancelQueuedRedemption { - return &icstypes.MsgCancelQueuedRedemption{ + func(s *KeeperTestSuite) *icstypes.MsgCancelRedemption { + return &icstypes.MsgCancelRedemption{ ChainId: "bob", Hash: hash, FromAddress: addressutils.GenerateAddressForTestWithPrefix("quick"), @@ -821,8 +821,8 @@ func (suite *KeeperTestSuite) TestMsgCancelQueuedRedemeption() { }, { "no hash exists", - func(s *KeeperTestSuite) *icstypes.MsgCancelQueuedRedemption { - return &icstypes.MsgCancelQueuedRedemption{ + func(s *KeeperTestSuite) *icstypes.MsgCancelRedemption { + return &icstypes.MsgCancelRedemption{ ChainId: s.chainB.ChainID, Hash: hash, FromAddress: addressutils.GenerateAddressForTestWithPrefix("quick"), @@ -831,8 +831,8 @@ func (suite *KeeperTestSuite) TestMsgCancelQueuedRedemeption() { fmt.Sprintf("no queued record with hash \"%s\" found", hash), }, { - "hash exists but not in correct status", - func(s *KeeperTestSuite) *icstypes.MsgCancelQueuedRedemption { + "hash exists but in unbond status, no errors", + func(s *KeeperTestSuite) *icstypes.MsgCancelRedemption { ctx := s.chainA.GetContext() k := s.GetQuicksilverApp(suite.chainA).InterchainstakingKeeper address := addressutils.GenerateAddressForTestWithPrefix("quick") @@ -845,17 +845,44 @@ func (suite *KeeperTestSuite) TestMsgCancelQueuedRedemeption() { Txhash: hash, }) - return &icstypes.MsgCancelQueuedRedemption{ + return &icstypes.MsgCancelRedemption{ ChainId: s.chainB.ChainID, Hash: hash, FromAddress: address, } }, - fmt.Sprintf("no queued record with hash \"%s\" found", hash), + fmt.Sprintf("cannot cancel unbond \"%s\" with no errors", hash), + }, + { + "hash exists in queued status, with errors", + func(s *KeeperTestSuite) *icstypes.MsgCancelRedemption { + ctx := s.chainA.GetContext() + k := s.GetQuicksilverApp(suite.chainA).InterchainstakingKeeper + address := addressutils.GenerateAddressForTestWithPrefix("quick") + _ = k.SetWithdrawalRecord(ctx, icstypes.WithdrawalRecord{ + ChainId: s.chainB.ChainID, + Delegator: address, + BurnAmount: sdk.NewCoin("uqatom", math.NewInt(500)), + Status: icstypes.WithdrawStatusUnbond, + CompletionTime: ctx.BlockHeader().Time.Add(time.Hour * 72), + Txhash: hash, + SendErrors: 1, + }) + + suite.NoError(k.BankKeeper.MintCoins(ctx, icstypes.ModuleName, sdk.NewCoins(sdk.NewCoin("uqatom", math.NewInt(500))))) + suite.NoError(k.BankKeeper.SendCoinsFromModuleToModule(ctx, icstypes.ModuleName, icstypes.EscrowModuleAccount, sdk.NewCoins(sdk.NewCoin("uqatom", math.NewInt(500))))) + + return &icstypes.MsgCancelRedemption{ + ChainId: s.chainB.ChainID, + Hash: hash, + FromAddress: address, + } + }, + "", }, { "hash exists in correct status but different user", - func(s *KeeperTestSuite) *icstypes.MsgCancelQueuedRedemption { + func(s *KeeperTestSuite) *icstypes.MsgCancelRedemption { ctx := s.chainA.GetContext() k := s.GetQuicksilverApp(suite.chainA).InterchainstakingKeeper // generate two addresses, one for the withdrawal record we are looking up; one for the tx. @@ -870,7 +897,7 @@ func (suite *KeeperTestSuite) TestMsgCancelQueuedRedemeption() { Txhash: hash, }) - return &icstypes.MsgCancelQueuedRedemption{ + return &icstypes.MsgCancelRedemption{ ChainId: s.chainB.ChainID, Hash: hash, FromAddress: address, @@ -880,7 +907,7 @@ func (suite *KeeperTestSuite) TestMsgCancelQueuedRedemeption() { }, { "valid", - func(s *KeeperTestSuite) *icstypes.MsgCancelQueuedRedemption { + func(s *KeeperTestSuite) *icstypes.MsgCancelRedemption { ctx := s.chainA.GetContext() k := s.GetQuicksilverApp(suite.chainA).InterchainstakingKeeper address := addressutils.GenerateAddressForTestWithPrefix("quick") @@ -896,7 +923,7 @@ func (suite *KeeperTestSuite) TestMsgCancelQueuedRedemeption() { suite.NoError(k.BankKeeper.MintCoins(ctx, icstypes.ModuleName, sdk.NewCoins(sdk.NewCoin("uqatom", math.NewInt(500))))) suite.NoError(k.BankKeeper.SendCoinsFromModuleToModule(ctx, icstypes.ModuleName, icstypes.EscrowModuleAccount, sdk.NewCoins(sdk.NewCoin("uqatom", math.NewInt(500))))) - return &icstypes.MsgCancelQueuedRedemption{ + return &icstypes.MsgCancelRedemption{ ChainId: s.chainB.ChainID, Hash: hash, FromAddress: address, @@ -904,6 +931,32 @@ func (suite *KeeperTestSuite) TestMsgCancelQueuedRedemeption() { }, "", }, + { + "valid - governance", + func(s *KeeperTestSuite) *icstypes.MsgCancelRedemption { + ctx := s.chainA.GetContext() + k := s.GetQuicksilverApp(suite.chainA).InterchainstakingKeeper + address := addressutils.GenerateAddressForTestWithPrefix("quick") + _ = k.SetWithdrawalRecord(ctx, icstypes.WithdrawalRecord{ + ChainId: s.chainB.ChainID, + Delegator: address, + BurnAmount: sdk.NewCoin("uqatom", math.NewInt(500)), + Status: icstypes.WithdrawStatusQueued, + CompletionTime: ctx.BlockHeader().Time.Add(time.Hour * 72), + Txhash: hash, + }) + + suite.NoError(k.BankKeeper.MintCoins(ctx, icstypes.ModuleName, sdk.NewCoins(sdk.NewCoin("uqatom", math.NewInt(500))))) + suite.NoError(k.BankKeeper.SendCoinsFromModuleToModule(ctx, icstypes.ModuleName, icstypes.EscrowModuleAccount, sdk.NewCoins(sdk.NewCoin("uqatom", math.NewInt(500))))) + + return &icstypes.MsgCancelRedemption{ + ChainId: s.chainB.ChainID, + Hash: hash, + FromAddress: k.GetGovAuthority(ctx), + } + }, + "", + }, } for _, tt := range tests { @@ -933,6 +986,401 @@ func (suite *KeeperTestSuite) TestMsgCancelQueuedRedemeption() { } } +func (suite *KeeperTestSuite) TestMsgRequeueRedemeption() { + hash := randomutils.GenerateRandomHashAsHex(32) + tests := []struct { + name string + malleate func(s *KeeperTestSuite) *icstypes.MsgRequeueRedemption + expectErr string + }{ + { + "no zone exists", + func(s *KeeperTestSuite) *icstypes.MsgRequeueRedemption { + return &icstypes.MsgRequeueRedemption{ + ChainId: "bob", + Hash: hash, + FromAddress: addressutils.GenerateAddressForTestWithPrefix("quick"), + } + }, + fmt.Sprintf("no unbonding record with hash \"%s\" found", hash), + }, + { + "no hash exists", + func(s *KeeperTestSuite) *icstypes.MsgRequeueRedemption { + return &icstypes.MsgRequeueRedemption{ + ChainId: s.chainB.ChainID, + Hash: hash, + FromAddress: addressutils.GenerateAddressForTestWithPrefix("quick"), + } + }, + fmt.Sprintf("no unbonding record with hash \"%s\" found", hash), + }, + { + "hash exists but in unbond status, no errors", + func(s *KeeperTestSuite) *icstypes.MsgRequeueRedemption { + ctx := s.chainA.GetContext() + k := s.GetQuicksilverApp(suite.chainA).InterchainstakingKeeper + address := addressutils.GenerateAddressForTestWithPrefix("quick") + _ = k.SetWithdrawalRecord(ctx, icstypes.WithdrawalRecord{ + ChainId: s.chainB.ChainID, + Delegator: address, + BurnAmount: sdk.NewCoin("uqatom", math.NewInt(500)), + Status: icstypes.WithdrawStatusUnbond, + CompletionTime: ctx.BlockHeader().Time.Add(time.Hour * 72), + Txhash: hash, + }) + + return &icstypes.MsgRequeueRedemption{ + ChainId: s.chainB.ChainID, + Hash: hash, + FromAddress: address, + } + }, + fmt.Sprintf("cannot requeue unbond \"%s\" with no errors", hash), + }, + { + "hash exists in queued status, with errors", + func(s *KeeperTestSuite) *icstypes.MsgRequeueRedemption { + ctx := s.chainA.GetContext() + k := s.GetQuicksilverApp(suite.chainA).InterchainstakingKeeper + address := addressutils.GenerateAddressForTestWithPrefix("quick") + _ = k.SetWithdrawalRecord(ctx, icstypes.WithdrawalRecord{ + ChainId: s.chainB.ChainID, + Delegator: address, + BurnAmount: sdk.NewCoin("uqatom", math.NewInt(500)), + Status: icstypes.WithdrawStatusUnbond, + CompletionTime: ctx.BlockHeader().Time.Add(time.Hour * 72), + Txhash: hash, + SendErrors: 1, + }) + + return &icstypes.MsgRequeueRedemption{ + ChainId: s.chainB.ChainID, + Hash: hash, + FromAddress: address, + } + }, + "", + }, + { + "hash exists in correct status but different user", + func(s *KeeperTestSuite) *icstypes.MsgRequeueRedemption { + ctx := s.chainA.GetContext() + k := s.GetQuicksilverApp(suite.chainA).InterchainstakingKeeper + // generate two addresses, one for the withdrawal record we are looking up; one for the tx. + withdrawalAddress := addressutils.GenerateAddressForTestWithPrefix("quick") + address := addressutils.GenerateAddressForTestWithPrefix("quick") + _ = k.SetWithdrawalRecord(ctx, icstypes.WithdrawalRecord{ + ChainId: s.chainB.ChainID, + Delegator: withdrawalAddress, + BurnAmount: sdk.NewCoin("uqatom", math.NewInt(500)), + Status: icstypes.WithdrawStatusUnbond, + CompletionTime: ctx.BlockHeader().Time.Add(time.Hour * 72), + Txhash: hash, + SendErrors: 1, + }) + + return &icstypes.MsgRequeueRedemption{ + ChainId: s.chainB.ChainID, + Hash: hash, + FromAddress: address, + } + }, + fmt.Sprintf("incorrect user for record with hash \"%s\"", hash), + }, + { + "valid - governance", + func(s *KeeperTestSuite) *icstypes.MsgRequeueRedemption { + ctx := s.chainA.GetContext() + k := s.GetQuicksilverApp(suite.chainA).InterchainstakingKeeper + address := addressutils.GenerateAddressForTestWithPrefix("quick") + _ = k.SetWithdrawalRecord(ctx, icstypes.WithdrawalRecord{ + ChainId: s.chainB.ChainID, + Delegator: address, + BurnAmount: sdk.NewCoin("uqatom", math.NewInt(500)), + Status: icstypes.WithdrawStatusUnbond, + CompletionTime: ctx.BlockHeader().Time.Add(time.Hour * 72), + Txhash: hash, + SendErrors: 1, + }) + + return &icstypes.MsgRequeueRedemption{ + ChainId: s.chainB.ChainID, + Hash: hash, + FromAddress: k.GetGovAuthority(ctx), + } + }, + "", + }, + } + + for _, tt := range tests { + tt := tt + + suite.Run(tt.name, func() { + suite.SetupTest() + suite.setupTestZones() + + msg := tt.malleate(suite) + + msgSrv := icskeeper.NewMsgServerImpl(suite.GetQuicksilverApp(suite.chainA).InterchainstakingKeeper) + res, err := msgSrv.RequeueRedemption(sdk.WrapSDKContext(suite.chainA.GetContext()), msg) + if len(tt.expectErr) != 0 { + suite.ErrorContains(err, tt.expectErr) + suite.Nil(res) + } else { + suite.NoError(err) + suite.NotNil(res) + } + + qapp := suite.GetQuicksilverApp(suite.chainA) + icsKeeper := qapp.InterchainstakingKeeper + _, found := icsKeeper.GetZone(suite.chainA.GetContext(), suite.chainB.ChainID) + suite.True(found) + }) + } +} + +func (suite *KeeperTestSuite) TestMsgUpdateRedemption() { + hash := randomutils.GenerateRandomHashAsHex(32) + tests := []struct { + name string + malleate func(s *KeeperTestSuite) *icstypes.MsgUpdateRedemption + expectErr string + assert func(s *KeeperTestSuite) bool + }{ + { + "no zone exists", + func(s *KeeperTestSuite) *icstypes.MsgUpdateRedemption { + k := s.GetQuicksilverApp(suite.chainA).InterchainstakingKeeper + ctx := s.chainA.GetContext() + return &icstypes.MsgUpdateRedemption{ + ChainId: "bob", + Hash: hash, + NewStatus: icstypes.WithdrawStatusUnbond, + FromAddress: k.GetGovAuthority(ctx), + } + }, + fmt.Sprintf("no unbonding record with hash \"%s\" found", hash), + nil, + }, + { + "no hash exists", + func(s *KeeperTestSuite) *icstypes.MsgUpdateRedemption { + k := s.GetQuicksilverApp(suite.chainA).InterchainstakingKeeper + ctx := s.chainA.GetContext() + return &icstypes.MsgUpdateRedemption{ + ChainId: s.chainB.ChainID, + Hash: hash, + NewStatus: icstypes.WithdrawStatusUnbond, + FromAddress: k.GetGovAuthority(ctx), + } + }, + fmt.Sprintf("no unbonding record with hash \"%s\" found", hash), + nil, + }, + { + "invalid - cannot transition to send", + func(s *KeeperTestSuite) *icstypes.MsgUpdateRedemption { + ctx := s.chainA.GetContext() + k := s.GetQuicksilverApp(suite.chainA).InterchainstakingKeeper + address := addressutils.GenerateAddressForTestWithPrefix("quick") + _ = k.SetWithdrawalRecord(ctx, icstypes.WithdrawalRecord{ + ChainId: s.chainB.ChainID, + Delegator: address, + BurnAmount: sdk.NewCoin("uqatom", math.NewInt(500)), + Status: icstypes.WithdrawStatusQueued, + CompletionTime: ctx.BlockHeader().Time.Add(time.Hour * 72), + Txhash: hash, + SendErrors: 1, + }) + + return &icstypes.MsgUpdateRedemption{ + ChainId: s.chainB.ChainID, + Hash: hash, + NewStatus: icstypes.WithdrawStatusSend, + FromAddress: k.GetGovAuthority(ctx), + } + }, + "new status WithdrawStatusSend not supported", + nil, + }, + { + "invalid - cannot transition to tokenize", + func(s *KeeperTestSuite) *icstypes.MsgUpdateRedemption { + ctx := s.chainA.GetContext() + k := s.GetQuicksilverApp(suite.chainA).InterchainstakingKeeper + address := addressutils.GenerateAddressForTestWithPrefix("quick") + _ = k.SetWithdrawalRecord(ctx, icstypes.WithdrawalRecord{ + ChainId: s.chainB.ChainID, + Delegator: address, + BurnAmount: sdk.NewCoin("uqatom", math.NewInt(500)), + Status: icstypes.WithdrawStatusQueued, + CompletionTime: ctx.BlockHeader().Time.Add(time.Hour * 72), + Txhash: hash, + SendErrors: 1, + }) + + return &icstypes.MsgUpdateRedemption{ + ChainId: s.chainB.ChainID, + Hash: hash, + NewStatus: icstypes.WithdrawStatusTokenize, + FromAddress: k.GetGovAuthority(ctx), + } + }, + "new status WithdrawStatusTokenize not supported", + nil, + }, + { + "invalid - cannot transition to send", + func(s *KeeperTestSuite) *icstypes.MsgUpdateRedemption { + ctx := s.chainA.GetContext() + k := s.GetQuicksilverApp(suite.chainA).InterchainstakingKeeper + address := addressutils.GenerateAddressForTestWithPrefix("quick") + _ = k.SetWithdrawalRecord(ctx, icstypes.WithdrawalRecord{ + ChainId: s.chainB.ChainID, + Delegator: address, + BurnAmount: sdk.NewCoin("uqatom", math.NewInt(500)), + Status: icstypes.WithdrawStatusQueued, + CompletionTime: ctx.BlockHeader().Time.Add(time.Hour * 72), + Txhash: hash, + SendErrors: 1, + }) + + return &icstypes.MsgUpdateRedemption{ + ChainId: s.chainB.ChainID, + Hash: hash, + NewStatus: 0, + FromAddress: k.GetGovAuthority(ctx), + } + }, + "new status not provided or invalid", + nil, + }, + { + "valid - target complete", + func(s *KeeperTestSuite) *icstypes.MsgUpdateRedemption { + ctx := s.chainA.GetContext() + k := s.GetQuicksilverApp(suite.chainA).InterchainstakingKeeper + address := addressutils.GenerateAddressForTestWithPrefix("quick") + _ = k.SetWithdrawalRecord(ctx, icstypes.WithdrawalRecord{ + ChainId: s.chainB.ChainID, + Delegator: address, + BurnAmount: sdk.NewCoin("uqatom", math.NewInt(500)), + Status: icstypes.WithdrawStatusUnbond, + CompletionTime: ctx.BlockHeader().Time.Add(time.Hour * 72), + Txhash: hash, + SendErrors: 1, + }) + + return &icstypes.MsgUpdateRedemption{ + ChainId: s.chainB.ChainID, + Hash: hash, + NewStatus: icstypes.WithdrawStatusCompleted, + FromAddress: k.GetGovAuthority(ctx), + } + }, + "", + func(s *KeeperTestSuite) bool { + qapp := suite.GetQuicksilverApp(suite.chainA) + icsKeeper := qapp.InterchainstakingKeeper + _, found := icsKeeper.GetWithdrawalRecord(suite.chainA.GetContext(), s.chainB.ChainID, hash, icstypes.WithdrawStatusCompleted) + return found + }, + }, + { + "valid - target unbonding", + func(s *KeeperTestSuite) *icstypes.MsgUpdateRedemption { + ctx := s.chainA.GetContext() + k := s.GetQuicksilverApp(suite.chainA).InterchainstakingKeeper + address := addressutils.GenerateAddressForTestWithPrefix("quick") + _ = k.SetWithdrawalRecord(ctx, icstypes.WithdrawalRecord{ + ChainId: s.chainB.ChainID, + Delegator: address, + BurnAmount: sdk.NewCoin("uqatom", math.NewInt(500)), + Status: icstypes.WithdrawStatusSend, + CompletionTime: ctx.BlockHeader().Time.Add(time.Hour * 72), + Txhash: hash, + SendErrors: 1, + }) + + return &icstypes.MsgUpdateRedemption{ + ChainId: s.chainB.ChainID, + Hash: hash, + NewStatus: icstypes.WithdrawStatusUnbond, + FromAddress: k.GetGovAuthority(ctx), + } + }, + "", + func(s *KeeperTestSuite) bool { + qapp := suite.GetQuicksilverApp(suite.chainA) + icsKeeper := qapp.InterchainstakingKeeper + _, found := icsKeeper.GetWithdrawalRecord(suite.chainA.GetContext(), s.chainB.ChainID, hash, icstypes.WithdrawStatusUnbond) + return found + }, + }, + { + "valid - target queued", + func(s *KeeperTestSuite) *icstypes.MsgUpdateRedemption { + ctx := s.chainA.GetContext() + k := s.GetQuicksilverApp(suite.chainA).InterchainstakingKeeper + address := addressutils.GenerateAddressForTestWithPrefix("quick") + _ = k.SetWithdrawalRecord(ctx, icstypes.WithdrawalRecord{ + ChainId: s.chainB.ChainID, + Delegator: address, + BurnAmount: sdk.NewCoin("uqatom", math.NewInt(500)), + Status: icstypes.WithdrawStatusUnbond, + CompletionTime: ctx.BlockHeader().Time.Add(time.Hour * 72), + Txhash: hash, + SendErrors: 1, + }) + + return &icstypes.MsgUpdateRedemption{ + ChainId: s.chainB.ChainID, + Hash: hash, + NewStatus: icstypes.WithdrawStatusQueued, + FromAddress: k.GetGovAuthority(ctx), + } + }, + "", + func(s *KeeperTestSuite) bool { + qapp := suite.GetQuicksilverApp(suite.chainA) + icsKeeper := qapp.InterchainstakingKeeper + record, found := icsKeeper.GetWithdrawalRecord(suite.chainA.GetContext(), s.chainB.ChainID, hash, icstypes.WithdrawStatusQueued) + + return found && record.Distribution == nil && record.Amount == nil && record.SendErrors == 0 + }, + }, + } + + for _, tt := range tests { + tt := tt + + suite.Run(tt.name, func() { + suite.SetupTest() + suite.setupTestZones() + + msg := tt.malleate(suite) + + msgSrv := icskeeper.NewMsgServerImpl(suite.GetQuicksilverApp(suite.chainA).InterchainstakingKeeper) + res, err := msgSrv.UpdateRedemption(sdk.WrapSDKContext(suite.chainA.GetContext()), msg) + if len(tt.expectErr) != 0 { + suite.ErrorContains(err, tt.expectErr) + suite.Nil(res) + } else { + suite.NoError(err) + suite.NotNil(res) + suite.True(tt.assert(suite)) + } + + qapp := suite.GetQuicksilverApp(suite.chainA) + icsKeeper := qapp.InterchainstakingKeeper + _, found := icsKeeper.GetZone(suite.chainA.GetContext(), suite.chainB.ChainID) + suite.True(found) + }) + } +} + func (suite *KeeperTestSuite) TestMsgGovAddValidatorToDenyList() { dummyChainID := "dummychain" testValAddr, _ := sdk.ValAddressFromHex(suite.chainB.Vals.Validators[0].Address.String()) diff --git a/x/interchainstaking/types/codec.go b/x/interchainstaking/types/codec.go index 2c09d1d03..8327f8453 100644 --- a/x/interchainstaking/types/codec.go +++ b/x/interchainstaking/types/codec.go @@ -19,7 +19,8 @@ var ( func RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) { cdc.RegisterConcrete(&MsgSignalIntent{}, "quicksilver/MsgSignalIntent", nil) cdc.RegisterConcrete(&MsgRequestRedemption{}, "quicksilver/MsgRequestRedemption", nil) - cdc.RegisterConcrete(&MsgCancelQueuedRedemption{}, "quicksilver/MsgCancelQueuedRedemption", nil) + cdc.RegisterConcrete(&MsgCancelRedemption{}, "quicksilver/MsgCancelRedemption", nil) + cdc.RegisterConcrete(&MsgRequeueRedemption{}, "quicksilver/MsgRequeueRedemption", nil) cdc.RegisterConcrete(&RegisterZoneProposal{}, "quicksilver/RegisterZoneProposal", nil) cdc.RegisterConcrete(&UpdateZoneProposal{}, "quicksilver/UpdateZoneProposal", nil) lsmstakingtypes.RegisterLegacyAminoCodec(cdc) @@ -31,7 +32,8 @@ func RegisterInterfaces(registry types.InterfaceRegistry) { (*sdk.Msg)(nil), &MsgSignalIntent{}, &MsgRequestRedemption{}, - &MsgCancelQueuedRedemption{}, + &MsgCancelRedemption{}, + &MsgRequeueRedemption{}, &MsgGovCloseChannel{}, &MsgGovReopenChannel{}, &MsgGovSetLsmCaps{}, diff --git a/x/interchainstaking/types/events.go b/x/interchainstaking/types/events.go index 4242a3951..30633da78 100644 --- a/x/interchainstaking/types/events.go +++ b/x/interchainstaking/types/events.go @@ -4,6 +4,8 @@ const ( EventTypeRegisterZone = "register_zone" EventTypeRedemptionRequest = "request_redemption" EventTypeRedemptionCancellation = "cancel_redemption" + EventTypeRedemptionRequeue = "requeue_redemption" + EventTypeUpdateRedemption = "update_redemption" EventTypeSetIntent = "set_intent" EventTypeCloseICA = "close_ica_channel" EventTypeReopenICA = "reopen_ica_channel" @@ -21,6 +23,8 @@ const ( AttributeKeyChannelID = "channel_id" AttributeKeyPortID = "port_name" AttributeKeyUser = "user_address" + AttributeKeyHash = "hash" + AttributeKeyNewStatus = "new_status" AttributeLsmValidatorCap = "lsm_validator_cap" AttributeLsmValidatorBondCap = "lsm_validator_bond_cap" diff --git a/x/interchainstaking/types/interchainstaking.pb.go b/x/interchainstaking/types/interchainstaking.pb.go index 08da71f13..c227836db 100644 --- a/x/interchainstaking/types/interchainstaking.pb.go +++ b/x/interchainstaking/types/interchainstaking.pb.go @@ -521,6 +521,7 @@ type WithdrawalRecord struct { Requeued bool `protobuf:"varint,10,opt,name=requeued,proto3" json:"requeued,omitempty"` Acknowledged bool `protobuf:"varint,11,opt,name=acknowledged,proto3" json:"acknowledged,omitempty"` EpochNumber int64 `protobuf:"varint,12,opt,name=epoch_number,json=epochNumber,proto3" json:"epoch_number,omitempty"` + SendErrors int64 `protobuf:"varint,13,opt,name=send_errors,json=sendErrors,proto3" json:"send_errors,omitempty"` } func (m *WithdrawalRecord) Reset() { *m = WithdrawalRecord{} } @@ -633,6 +634,13 @@ func (m *WithdrawalRecord) GetEpochNumber() int64 { return 0 } +func (m *WithdrawalRecord) GetSendErrors() int64 { + if m != nil { + return m.SendErrors + } + return 0 +} + type UnbondingRecord struct { ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` EpochNumber int64 `protobuf:"varint,2,opt,name=epoch_number,json=epochNumber,proto3" json:"epoch_number,omitempty"` @@ -1196,139 +1204,140 @@ func init() { } var fileDescriptor_0d755cfd37ef9fee = []byte{ - // 2104 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x59, 0xcb, 0x6f, 0x1b, 0xc7, - 0x19, 0x37, 0x29, 0x89, 0x14, 0x3f, 0x52, 0xa2, 0x34, 0x92, 0x9d, 0xf5, 0x4b, 0x64, 0xd8, 0x24, - 0x65, 0x61, 0x8b, 0x8c, 0x1c, 0xa0, 0x75, 0x83, 0xa2, 0x80, 0x28, 0xb9, 0x89, 0xd0, 0x58, 0x15, - 0x56, 0x4a, 0x83, 0xc6, 0x28, 0x16, 0xc3, 0xdd, 0x11, 0xb9, 0xf1, 0xee, 0x0c, 0xbd, 0x33, 0xd4, - 0xc3, 0xc7, 0xfc, 0x05, 0xb9, 0xf7, 0xd2, 0x5e, 0x83, 0x1e, 0xdd, 0x4b, 0xd1, 0x3f, 0x20, 0xc7, - 0xc0, 0xa7, 0xa2, 0x28, 0xe4, 0xc2, 0xbe, 0xe9, 0xd8, 0xbf, 0xa0, 0x98, 0xc7, 0x3e, 0xf4, 0x88, - 0x29, 0xd9, 0x4c, 0x4f, 0xe2, 0x7c, 0x8f, 0xdf, 0x37, 0x3b, 0xf3, 0xcd, 0xf7, 0xfd, 0x66, 0x04, - 0xf7, 0x9f, 0x0c, 0x7d, 0xf7, 0x31, 0xf7, 0x83, 0x3d, 0x12, 0xb5, 0x7d, 0x2a, 0x48, 0xe4, 0xf6, - 0xb1, 0x4f, 0xb9, 0xc0, 0x8f, 0x7d, 0xda, 0x6b, 0xef, 0xad, 0x9c, 0x15, 0xb6, 0x06, 0x11, 0x13, - 0x0c, 0xd5, 0x33, 0x9e, 0xad, 0xb3, 0x46, 0x7b, 0x2b, 0x37, 0x96, 0x5c, 0xc6, 0x43, 0xc6, 0xdb, - 0x5d, 0xcc, 0x49, 0x7b, 0x6f, 0xa5, 0x4b, 0x04, 0x5e, 0x69, 0xbb, 0xcc, 0xa7, 0x1a, 0xe1, 0xc6, - 0x75, 0xad, 0x77, 0xd4, 0xa8, 0xad, 0x07, 0x46, 0xb5, 0xd8, 0x63, 0x3d, 0xa6, 0xe5, 0xf2, 0x97, - 0x91, 0xd6, 0x7a, 0x8c, 0xf5, 0x02, 0xd2, 0x56, 0xa3, 0xee, 0x70, 0xb7, 0x2d, 0xfc, 0x90, 0x70, - 0x81, 0xc3, 0x81, 0x36, 0x68, 0xfc, 0x7d, 0x0e, 0x26, 0xbf, 0x64, 0x94, 0xa0, 0x9f, 0xc0, 0x8c, - 0xcb, 0x28, 0x25, 0xae, 0xf0, 0x19, 0x75, 0x7c, 0xcf, 0xca, 0xd5, 0x73, 0xcd, 0x92, 0x5d, 0x49, - 0x85, 0x1b, 0x1e, 0xba, 0x0e, 0xd3, 0x6a, 0xca, 0x52, 0x9f, 0x57, 0xfa, 0xa2, 0x1a, 0x6f, 0x78, - 0xe8, 0x73, 0xa8, 0x7a, 0x64, 0xc0, 0xb8, 0x2f, 0x1c, 0xec, 0x79, 0x11, 0xe1, 0xdc, 0x9a, 0xa8, - 0xe7, 0x9a, 0xe5, 0x7b, 0x77, 0x5b, 0xa3, 0x3e, 0xbb, 0xb5, 0xb1, 0xb6, 0xba, 0xea, 0xba, 0x6c, - 0x48, 0x85, 0x3d, 0x6b, 0x40, 0x56, 0x35, 0x06, 0x7a, 0x04, 0x68, 0xdf, 0x17, 0x7d, 0x2f, 0xc2, - 0xfb, 0x38, 0x48, 0x90, 0x27, 0xdf, 0x00, 0x79, 0x3e, 0xc5, 0x89, 0xc1, 0xff, 0x08, 0x0b, 0x03, - 0x12, 0xed, 0xb2, 0x28, 0xc4, 0xd4, 0x25, 0x09, 0xfa, 0xd4, 0x1b, 0xa0, 0xa3, 0x0c, 0x50, 0x66, - 0xee, 0x1e, 0x09, 0x48, 0x0f, 0xab, 0x25, 0x8d, 0xd1, 0x0b, 0x6f, 0x32, 0xf7, 0x14, 0x27, 0x06, - 0x7f, 0x1f, 0x66, 0xb1, 0xd6, 0x3a, 0x83, 0x88, 0xec, 0xfa, 0x07, 0x56, 0x51, 0x6d, 0xc8, 0x8c, - 0x91, 0x6e, 0x29, 0x21, 0xaa, 0x41, 0x39, 0x60, 0x2e, 0x0e, 0x1c, 0x8f, 0x50, 0x16, 0x5a, 0xd3, - 0xca, 0x06, 0x94, 0x68, 0x5d, 0x4a, 0xd0, 0x6d, 0x00, 0x99, 0x6d, 0x46, 0x5f, 0x52, 0xfa, 0x92, - 0x94, 0x68, 0x35, 0x81, 0x6a, 0x44, 0x3c, 0x12, 0x0e, 0xd4, 0x37, 0x44, 0x58, 0x10, 0x0b, 0xa4, - 0x4d, 0xe7, 0x57, 0xdf, 0x1d, 0xd5, 0xae, 0xfc, 0xeb, 0xa8, 0xf6, 0x41, 0xcf, 0x17, 0xfd, 0x61, - 0xb7, 0xe5, 0xb2, 0xd0, 0x24, 0xa4, 0xf9, 0xb3, 0xcc, 0xbd, 0xc7, 0x6d, 0x71, 0x38, 0x20, 0xbc, - 0xb5, 0x4e, 0xdc, 0xe7, 0xcf, 0x96, 0xc1, 0xe4, 0xeb, 0x3a, 0x71, 0xed, 0xd9, 0x14, 0xd4, 0xc6, - 0x82, 0x20, 0x0a, 0x8b, 0x01, 0xe6, 0xc2, 0x39, 0x1d, 0xab, 0x3c, 0x86, 0x58, 0x48, 0x22, 0xdb, - 0x27, 0xe3, 0xfd, 0x16, 0x60, 0x0f, 0x07, 0xbe, 0x87, 0x05, 0x8b, 0xb8, 0x55, 0xa9, 0x4f, 0x34, - 0xcb, 0xf7, 0xee, 0x8c, 0xde, 0x92, 0xdf, 0xc7, 0x3e, 0x76, 0xc6, 0x1d, 0x45, 0x30, 0x87, 0x7b, - 0xbd, 0x48, 0x6e, 0x10, 0x71, 0xa4, 0x1f, 0x15, 0xd6, 0x8c, 0x82, 0x5c, 0xb9, 0x04, 0xe4, 0x86, - 0x72, 0xec, 0x2c, 0x7e, 0xfb, 0xa2, 0x36, 0x77, 0x4a, 0xc8, 0xed, 0x6a, 0x12, 0x40, 0x4b, 0xe4, - 0xb6, 0x85, 0xc3, 0x40, 0xf8, 0x0e, 0x27, 0xd4, 0xb3, 0x66, 0xeb, 0xb9, 0xe6, 0xb4, 0x5d, 0x52, - 0x92, 0x6d, 0x42, 0x3d, 0xf4, 0x33, 0x98, 0x0b, 0xfc, 0x27, 0x43, 0xdf, 0xf3, 0xc5, 0xa1, 0x13, - 0x32, 0x6f, 0x18, 0x10, 0xab, 0xaa, 0x8c, 0xaa, 0x89, 0xfc, 0xa1, 0x12, 0xa3, 0x15, 0x58, 0xcc, - 0x9c, 0xb0, 0x7d, 0xec, 0x8b, 0x5e, 0xc4, 0x86, 0x03, 0x6b, 0xae, 0x9e, 0x6b, 0xce, 0xd8, 0x0b, - 0xa9, 0xee, 0x8b, 0x58, 0x85, 0x7e, 0x01, 0x96, 0xdf, 0x75, 0x1d, 0x4a, 0x0e, 0x84, 0x93, 0xae, - 0x83, 0xd3, 0xc7, 0xbc, 0x6f, 0xcd, 0xd7, 0x73, 0xcd, 0x8a, 0x7d, 0xd5, 0xef, 0xba, 0x9b, 0xe4, - 0x40, 0x24, 0x1f, 0xc2, 0x3f, 0xc5, 0xbc, 0x8f, 0x0e, 0x61, 0x29, 0xb1, 0x77, 0x38, 0x09, 0x4c, - 0xb5, 0xc1, 0x81, 0x4c, 0x48, 0xf9, 0xd3, 0x42, 0xf5, 0x5c, 0x73, 0xb2, 0xf3, 0xd1, 0xf1, 0x51, - 0xad, 0xfd, 0x7a, 0xcb, 0xbb, 0x5c, 0x44, 0x3e, 0xed, 0xdd, 0x65, 0xa1, 0x2f, 0xe4, 0xce, 0x1e, - 0xda, 0xb7, 0x12, 0x87, 0xed, 0xd8, 0x7e, 0x35, 0x31, 0x47, 0x7f, 0x80, 0x85, 0x3e, 0x0b, 0x3c, - 0x9f, 0xf6, 0x78, 0x36, 0xde, 0x82, 0x8a, 0xd7, 0x3c, 0x3e, 0xaa, 0xbd, 0x77, 0x8e, 0xfa, 0x6c, - 0x10, 0x14, 0x5b, 0x65, 0xa0, 0x6d, 0x98, 0x57, 0xc9, 0x4b, 0x06, 0xcc, 0xed, 0x3b, 0x7d, 0xe2, - 0xf7, 0xfa, 0xc2, 0x5a, 0xac, 0xe7, 0x9a, 0x13, 0x9d, 0x0f, 0x8e, 0x8f, 0x6a, 0x8d, 0x33, 0xca, - 0xb3, 0xb0, 0x55, 0x69, 0xf3, 0x40, 0x9a, 0x7c, 0xaa, 0x2c, 0xd0, 0x26, 0x4c, 0x88, 0xbd, 0xc0, - 0xba, 0x3a, 0x86, 0xfc, 0x97, 0x40, 0x68, 0x0b, 0xe6, 0x86, 0xb4, 0xcb, 0xa8, 0x9c, 0xbb, 0x33, - 0x20, 0x91, 0xcf, 0x3c, 0xeb, 0x9a, 0x9a, 0xe2, 0xfb, 0xc7, 0x47, 0xb5, 0x77, 0x4f, 0xeb, 0xce, - 0x99, 0x61, 0x62, 0xb2, 0xa5, 0x2c, 0xd0, 0x67, 0x50, 0x0d, 0x09, 0xe7, 0xb8, 0x47, 0xb8, 0x74, - 0x72, 0xc4, 0x81, 0xf5, 0x8e, 0x02, 0x7c, 0xef, 0xf8, 0xa8, 0x56, 0x3f, 0xa5, 0x3a, 0x8b, 0x37, - 0x13, 0x5b, 0x6c, 0x91, 0x68, 0xe7, 0x00, 0xfd, 0x12, 0xa6, 0x3d, 0xe2, 0xfa, 0x21, 0x0e, 0xb8, - 0x65, 0x29, 0x98, 0xdb, 0xc7, 0x47, 0xb5, 0xeb, 0xb1, 0xec, 0xac, 0x7f, 0x62, 0x8e, 0xee, 0xc0, - 0x7c, 0x3a, 0x7d, 0x42, 0x71, 0x37, 0x20, 0x9e, 0x75, 0x5d, 0x25, 0x7b, 0xfa, 0xcd, 0x0f, 0xb4, - 0x5c, 0x1e, 0x0c, 0xd3, 0x61, 0x78, 0x62, 0x7b, 0x43, 0x1f, 0x8c, 0x58, 0x1e, 0x9b, 0x36, 0x61, - 0x2e, 0x22, 0x62, 0x18, 0x51, 0x47, 0x30, 0x75, 0xcc, 0x48, 0x64, 0xdd, 0x54, 0xa6, 0xb3, 0x5a, - 0xbe, 0xc3, 0xb6, 0x95, 0x14, 0x5d, 0x85, 0x82, 0xcf, 0x9d, 0x95, 0x95, 0xfb, 0xd6, 0x2d, 0xa5, - 0x9f, 0xf2, 0xf9, 0xca, 0xca, 0x7d, 0xf4, 0x3b, 0x28, 0xf3, 0x61, 0xf7, 0x29, 0xa3, 0x64, 0x83, - 0xee, 0x32, 0xeb, 0xb6, 0x2a, 0xfc, 0xcb, 0xa3, 0x4b, 0xc2, 0x76, 0xea, 0x64, 0x67, 0x11, 0x90, - 0x0b, 0xb3, 0xde, 0x90, 0x0b, 0x47, 0xf4, 0x23, 0xc2, 0x65, 0x22, 0x5a, 0x4b, 0x97, 0xce, 0x8f, - 0x0d, 0x2a, 0x32, 0xf9, 0xb1, 0x41, 0x85, 0x3d, 0x23, 0x31, 0x77, 0x62, 0x48, 0xb9, 0x42, 0x22, - 0xc2, 0x94, 0xef, 0x92, 0xc8, 0x71, 0xfb, 0x98, 0x52, 0x12, 0x58, 0x35, 0xd5, 0x16, 0xaa, 0xb1, - 0x7c, 0x4d, 0x8b, 0x1b, 0x9b, 0x50, 0xce, 0xcc, 0x15, 0xdd, 0x82, 0x12, 0x1e, 0x8a, 0x3e, 0x8b, - 0x7c, 0x71, 0x68, 0xe8, 0x43, 0x2a, 0x40, 0xef, 0x42, 0x45, 0x35, 0x1a, 0x4d, 0x18, 0xd6, 0x0d, - 0x7f, 0x28, 0x4b, 0xd9, 0x9a, 0x16, 0x35, 0xfe, 0x96, 0x87, 0xe2, 0x67, 0x3c, 0x5c, 0xc3, 0x03, - 0x8e, 0x30, 0xcc, 0xa4, 0x05, 0xc0, 0xc5, 0x03, 0x0d, 0xf8, 0x96, 0x47, 0xa1, 0x92, 0x40, 0xae, - 0xe1, 0x01, 0xfa, 0x0a, 0x50, 0x1a, 0x42, 0xe6, 0x89, 0x8a, 0x93, 0x1f, 0x43, 0x9c, 0xb9, 0x04, - 0xb7, 0xc3, 0xa8, 0x27, 0x63, 0x3d, 0x02, 0xe8, 0x05, 0xac, 0x8b, 0x03, 0x15, 0x63, 0x62, 0x0c, - 0x31, 0x4a, 0x1a, 0x6f, 0x0d, 0x0f, 0x1a, 0x7f, 0xce, 0x03, 0xa4, 0x6c, 0x01, 0xdd, 0x83, 0x62, - 0x4c, 0x36, 0xf4, 0xa2, 0x59, 0xcf, 0x9f, 0x2d, 0x2f, 0x1a, 0x57, 0xc3, 0x1f, 0xb6, 0xd5, 0x79, - 0xb2, 0x63, 0x43, 0x44, 0xa0, 0xd8, 0xc5, 0x81, 0x64, 0x2f, 0x56, 0x5e, 0xb5, 0xae, 0xeb, 0x2d, - 0xe3, 0x20, 0x37, 0xa8, 0x65, 0xb8, 0x68, 0x6b, 0x8d, 0xf9, 0xb4, 0xf3, 0xa1, 0x9c, 0xf7, 0xb7, - 0x2f, 0x6a, 0xcd, 0x0b, 0xcc, 0x5b, 0x3a, 0x70, 0x3b, 0xc6, 0x46, 0x37, 0xa1, 0x34, 0x60, 0x91, - 0x70, 0x28, 0x0e, 0x89, 0x5e, 0x05, 0x7b, 0x5a, 0x0a, 0x36, 0x71, 0x48, 0xd0, 0xf2, 0x0f, 0x72, - 0xbd, 0xd2, 0x79, 0xec, 0xed, 0x0e, 0xcc, 0x1b, 0xd8, 0x4c, 0xd7, 0x9a, 0x52, 0x5d, 0x6b, 0xce, - 0x28, 0x92, 0x96, 0xd5, 0xf8, 0x53, 0x0e, 0x2a, 0xeb, 0xbe, 0xac, 0x22, 0xdd, 0xa1, 0x2a, 0xda, - 0x16, 0x14, 0xf7, 0x70, 0xc0, 0x06, 0x24, 0x32, 0xa9, 0x1a, 0x0f, 0xd1, 0x4d, 0x28, 0x3a, 0x38, - 0x94, 0x2b, 0xa9, 0x72, 0x61, 0xb2, 0x93, 0xb7, 0x72, 0x76, 0x61, 0x55, 0x49, 0xd0, 0x0e, 0x14, - 0x8c, 0x6e, 0x62, 0x0c, 0x47, 0xcf, 0x60, 0x35, 0x9e, 0x4d, 0xc1, 0xdc, 0x17, 0xc9, 0x07, 0xda, - 0xc4, 0x65, 0xd1, 0x49, 0xb2, 0x9d, 0x3b, 0x49, 0xb6, 0x7f, 0x0e, 0x25, 0xc3, 0x08, 0x59, 0x64, - 0x12, 0xf6, 0x87, 0xf7, 0x38, 0x35, 0x45, 0x36, 0x54, 0xbc, 0xcc, 0x22, 0x58, 0x13, 0x6a, 0xab, - 0x5b, 0xa3, 0x4b, 0x52, 0x76, 0xe9, 0xec, 0x13, 0x18, 0x72, 0x2e, 0x11, 0x71, 0xfd, 0x81, 0x2f, - 0x69, 0xcf, 0xe4, 0xa8, 0xb9, 0x24, 0xa6, 0xc8, 0x4d, 0x56, 0x72, 0x6a, 0xfc, 0x09, 0x67, 0xa0, - 0xd1, 0x53, 0x28, 0x77, 0x65, 0x05, 0x37, 0x91, 0x34, 0xf7, 0x7e, 0x4d, 0xa4, 0x5f, 0x9b, 0xed, - 0xfc, 0xe9, 0x05, 0x23, 0x3d, 0x7f, 0xb6, 0x5c, 0x36, 0x60, 0x72, 0x68, 0x83, 0x8c, 0x66, 0x52, - 0xe5, 0x1a, 0x14, 0xc4, 0x81, 0xe2, 0x44, 0x9a, 0x99, 0x9b, 0x91, 0x94, 0x73, 0x81, 0xc5, 0x90, - 0x2b, 0x36, 0x3e, 0x65, 0x9b, 0x11, 0x7a, 0x08, 0x55, 0x97, 0x85, 0x83, 0x80, 0x28, 0xa6, 0x23, - 0x2f, 0x6a, 0x8a, 0x8e, 0x97, 0xef, 0xdd, 0x68, 0xe9, 0x5b, 0x5c, 0x2b, 0xbe, 0xc5, 0xb5, 0x76, - 0xe2, 0x5b, 0x5c, 0x67, 0x5a, 0x4e, 0xf8, 0x9b, 0x17, 0xb5, 0x9c, 0x3d, 0x9b, 0x3a, 0x4b, 0x35, - 0xba, 0x01, 0xd3, 0x11, 0x79, 0x32, 0x24, 0x43, 0xe2, 0x29, 0xca, 0x3e, 0x6d, 0x27, 0x63, 0xd4, - 0x80, 0x0a, 0x76, 0x1f, 0x53, 0xb6, 0x1f, 0x10, 0xaf, 0x47, 0x3c, 0x45, 0xb3, 0xa7, 0xed, 0x13, - 0x32, 0x59, 0xaf, 0x35, 0x67, 0xa1, 0xc3, 0xb0, 0x4b, 0x22, 0xab, 0x22, 0xbb, 0xb2, 0x5d, 0x56, - 0xb2, 0x4d, 0x25, 0x6a, 0xfc, 0x25, 0x0f, 0xd5, 0xcf, 0xe3, 0x0e, 0x3b, 0x3a, 0x6b, 0x4f, 0x23, - 0xe6, 0xcf, 0x20, 0xca, 0x64, 0x4a, 0x4a, 0xa7, 0x39, 0x61, 0xaf, 0x49, 0xa6, 0xc4, 0x54, 0xde, - 0x86, 0x22, 0x12, 0x60, 0x41, 0x3c, 0xc7, 0xac, 0xf9, 0x64, 0x7d, 0x42, 0xde, 0x86, 0x8c, 0x74, - 0x47, 0x2f, 0xfd, 0x93, 0x4c, 0xce, 0xfd, 0xc8, 0x99, 0x10, 0x1f, 0xed, 0xaf, 0x27, 0x00, 0xc9, - 0xcb, 0x47, 0x7c, 0x7f, 0x1b, 0xcb, 0x32, 0x7d, 0x08, 0x05, 0xce, 0x86, 0x91, 0x4b, 0x46, 0xae, - 0x91, 0xb1, 0x43, 0x1f, 0x43, 0xd9, 0x23, 0x5c, 0xf8, 0x54, 0xd3, 0xde, 0x51, 0xe7, 0x34, 0x6b, - 0x9c, 0x2d, 0x88, 0x53, 0x8a, 0x9a, 0x65, 0x0b, 0xe2, 0x39, 0x59, 0x5b, 0x78, 0x8b, 0xac, 0x4d, - 0xeb, 0x6b, 0x71, 0x8c, 0xf5, 0xf5, 0xa8, 0x00, 0xa5, 0xe4, 0x2a, 0x82, 0x56, 0xa1, 0x6a, 0x6a, - 0xbd, 0x73, 0xd1, 0x3e, 0x39, 0x6b, 0x1c, 0x56, 0x93, 0x76, 0x29, 0xbf, 0x3a, 0xf4, 0x39, 0x4f, - 0xae, 0xaa, 0xe3, 0xe0, 0x0d, 0xb3, 0x29, 0xa8, 0xba, 0xa6, 0xf6, 0x24, 0x5b, 0x35, 0xc5, 0xdb, - 0xe1, 0x7d, 0x1c, 0x11, 0x3e, 0x16, 0xee, 0x50, 0x4d, 0x50, 0xb7, 0x15, 0x28, 0x72, 0xa0, 0xb2, - 0xc7, 0x84, 0xe2, 0xff, 0x6c, 0x9f, 0x44, 0x26, 0x3f, 0xde, 0x6e, 0xf1, 0xcb, 0x1a, 0x71, 0x4b, - 0x02, 0x22, 0x1b, 0xa6, 0xb8, 0xcb, 0x22, 0xa2, 0x32, 0xe8, 0x6d, 0xa7, 0xaf, 0xa1, 0x32, 0x85, - 0xb4, 0xa0, 0x0b, 0xac, 0x29, 0xa4, 0xd7, 0xa0, 0xf0, 0x15, 0xf6, 0x25, 0xb3, 0x2f, 0xaa, 0xba, - 0x66, 0x46, 0x68, 0x09, 0x40, 0xb0, 0xb0, 0xcb, 0x05, 0xa3, 0xc4, 0x53, 0xc5, 0x77, 0xda, 0xce, - 0x48, 0xd0, 0x27, 0x50, 0xd1, 0x96, 0x0e, 0xf7, 0x25, 0x11, 0xba, 0x4c, 0xf5, 0x2d, 0x6b, 0xcf, - 0x6d, 0xe9, 0x88, 0xbe, 0xce, 0xc1, 0xd5, 0x53, 0xcc, 0xd2, 0x6c, 0x9e, 0x7e, 0x3b, 0xd9, 0xbc, - 0xdc, 0xd7, 0xff, 0xf7, 0xa8, 0x76, 0xeb, 0x10, 0x87, 0xc1, 0xc7, 0x8d, 0x73, 0x41, 0x1b, 0xf6, - 0xc2, 0x09, 0xba, 0x69, 0xb6, 0xf4, 0x31, 0xcc, 0xe8, 0xab, 0x7e, 0x1c, 0x5b, 0xbf, 0xa5, 0xfc, - 0xe6, 0xd2, 0xb1, 0x17, 0x75, 0xec, 0x13, 0x60, 0x0d, 0xbb, 0xa2, 0xc7, 0x3a, 0x58, 0xe3, 0xaf, - 0x39, 0xa8, 0xae, 0xc7, 0x39, 0x65, 0x9e, 0x28, 0x4e, 0x90, 0x94, 0xdc, 0xc5, 0x49, 0x0a, 0x86, - 0xa2, 0x7e, 0x44, 0xe1, 0x86, 0x8a, 0x8e, 0xed, 0x15, 0x25, 0xc6, 0x6d, 0xfc, 0x23, 0x07, 0xd5, - 0x53, 0x5a, 0xd4, 0xb9, 0x7c, 0x55, 0x38, 0xed, 0x80, 0x08, 0x14, 0xf6, 0xf5, 0xf5, 0x5f, 0x57, - 0x83, 0x87, 0x97, 0x5e, 0xec, 0x19, 0xbd, 0xd8, 0x1a, 0xa5, 0x71, 0x2a, 0xef, 0x0b, 0xb1, 0x38, - 0x0f, 0xb0, 0x9e, 0x74, 0x14, 0xf4, 0xc9, 0xb9, 0xef, 0x8c, 0xa3, 0x26, 0x7f, 0xce, 0x9b, 0xe2, - 0x03, 0x98, 0x4f, 0x33, 0x2c, 0xc6, 0x19, 0x45, 0x2f, 0xd3, 0xbb, 0x4e, 0x0c, 0xf3, 0xe4, 0x04, - 0x47, 0xfe, 0x7f, 0x74, 0x59, 0x79, 0xe4, 0xcd, 0xbb, 0xcb, 0xa4, 0xea, 0x96, 0x66, 0x24, 0x2f, - 0xb3, 0x51, 0xa6, 0xf9, 0x3a, 0x84, 0x7a, 0xba, 0x87, 0xd9, 0xd5, 0xac, 0xfc, 0x01, 0xf5, 0x1a, - 0xdb, 0xb0, 0xb0, 0xc5, 0x22, 0xb1, 0x96, 0xbc, 0x77, 0xef, 0x0c, 0x07, 0xc1, 0x05, 0xdf, 0xc5, - 0xdf, 0x81, 0xa2, 0xba, 0xd6, 0x24, 0xcf, 0xe2, 0x05, 0x39, 0xdc, 0xf0, 0x1a, 0xff, 0xce, 0x43, - 0xd1, 0x26, 0x2e, 0xf1, 0x07, 0xe2, 0x75, 0x2d, 0x5f, 0xf6, 0x73, 0xfd, 0xc0, 0x90, 0x1f, 0xd9, - 0xcf, 0xf5, 0x93, 0x43, 0x4a, 0x2e, 0x27, 0x4e, 0x90, 0xcb, 0x94, 0x55, 0x4f, 0xfe, 0x78, 0xac, - 0x7a, 0x0d, 0x60, 0xd7, 0x8f, 0xb8, 0x70, 0x38, 0x21, 0xd4, 0x50, 0xa9, 0x51, 0x65, 0x32, 0xa7, - 0xca, 0x64, 0x49, 0xf9, 0x6d, 0x13, 0x42, 0x51, 0x07, 0x4a, 0xa6, 0xf7, 0x13, 0xef, 0x82, 0x94, - 0xc1, 0x60, 0x24, 0x6e, 0x9d, 0x47, 0xdf, 0xbd, 0x5c, 0xca, 0x7d, 0xff, 0x72, 0x29, 0xf7, 0x9f, - 0x97, 0x4b, 0xb9, 0x6f, 0x5e, 0x2d, 0x5d, 0xf9, 0xfe, 0xd5, 0xd2, 0x95, 0x7f, 0xbe, 0x5a, 0xba, - 0xf2, 0xe5, 0x6a, 0xe6, 0xa3, 0x32, 0xd5, 0x63, 0xf9, 0x29, 0xa3, 0x24, 0x2b, 0x68, 0x1f, 0x9c, - 0xf3, 0x3f, 0x1c, 0xf5, 0xcd, 0xdd, 0x82, 0x9a, 0xc5, 0x47, 0xff, 0x0b, 0x00, 0x00, 0xff, 0xff, - 0x5b, 0xa4, 0xa5, 0xa9, 0xf1, 0x19, 0x00, 0x00, + // 2124 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x59, 0x5b, 0x6f, 0x1b, 0xc7, + 0x15, 0x36, 0x29, 0x89, 0x14, 0x0f, 0x29, 0x51, 0x1a, 0xc9, 0xc9, 0xfa, 0x26, 0x32, 0x6c, 0x92, + 0xb2, 0xb0, 0x45, 0x46, 0x0e, 0x90, 0xba, 0x41, 0x51, 0x40, 0x94, 0xdc, 0x44, 0x68, 0xac, 0x0a, + 0x2b, 0xa5, 0x41, 0x63, 0x14, 0x8b, 0xe1, 0xee, 0x88, 0xdc, 0x78, 0x77, 0x87, 0x9e, 0x19, 0xea, + 0xe2, 0xc7, 0xfc, 0x82, 0xbc, 0xf7, 0xa5, 0x7d, 0x0d, 0xfa, 0xe8, 0xbe, 0x14, 0xfd, 0x01, 0x79, + 0x0c, 0x0c, 0x14, 0x28, 0x8a, 0x42, 0x2e, 0xec, 0x37, 0x3d, 0xf6, 0x17, 0x14, 0x73, 0xd9, 0x8b, + 0x2e, 0x31, 0x25, 0x9b, 0xe9, 0x93, 0x38, 0xe7, 0xf2, 0x9d, 0xd9, 0x99, 0x33, 0xe7, 0x7c, 0x33, + 0x82, 0x7b, 0x8f, 0x87, 0xbe, 0xfb, 0x88, 0xfb, 0xc1, 0x1e, 0x61, 0x6d, 0x3f, 0x12, 0x84, 0xb9, + 0x7d, 0xec, 0x47, 0x5c, 0xe0, 0x47, 0x7e, 0xd4, 0x6b, 0xef, 0xad, 0x9c, 0x15, 0xb6, 0x06, 0x8c, + 0x0a, 0x8a, 0xea, 0x19, 0xcf, 0xd6, 0x59, 0xa3, 0xbd, 0x95, 0xeb, 0x4b, 0x2e, 0xe5, 0x21, 0xe5, + 0xed, 0x2e, 0xe6, 0xa4, 0xbd, 0xb7, 0xd2, 0x25, 0x02, 0xaf, 0xb4, 0x5d, 0xea, 0x47, 0x1a, 0xe1, + 0xfa, 0x35, 0xad, 0x77, 0xd4, 0xa8, 0xad, 0x07, 0x46, 0xb5, 0xd8, 0xa3, 0x3d, 0xaa, 0xe5, 0xf2, + 0x97, 0x91, 0xd6, 0x7a, 0x94, 0xf6, 0x02, 0xd2, 0x56, 0xa3, 0xee, 0x70, 0xb7, 0x2d, 0xfc, 0x90, + 0x70, 0x81, 0xc3, 0x81, 0x36, 0x68, 0xfc, 0x6d, 0x0e, 0x26, 0xbf, 0xa4, 0x11, 0x41, 0x3f, 0x81, + 0x19, 0x97, 0x46, 0x11, 0x71, 0x85, 0x4f, 0x23, 0xc7, 0xf7, 0xac, 0x5c, 0x3d, 0xd7, 0x2c, 0xd9, + 0x95, 0x54, 0xb8, 0xe1, 0xa1, 0x6b, 0x30, 0xad, 0xa6, 0x2c, 0xf5, 0x79, 0xa5, 0x2f, 0xaa, 0xf1, + 0x86, 0x87, 0x3e, 0x87, 0xaa, 0x47, 0x06, 0x94, 0xfb, 0xc2, 0xc1, 0x9e, 0xc7, 0x08, 0xe7, 0xd6, + 0x44, 0x3d, 0xd7, 0x2c, 0xdf, 0xbd, 0xd3, 0x1a, 0xf5, 0xd9, 0xad, 0x8d, 0xb5, 0xd5, 0x55, 0xd7, + 0xa5, 0xc3, 0x48, 0xd8, 0xb3, 0x06, 0x64, 0x55, 0x63, 0xa0, 0x87, 0x80, 0xf6, 0x7d, 0xd1, 0xf7, + 0x18, 0xde, 0xc7, 0x41, 0x82, 0x3c, 0xf9, 0x1a, 0xc8, 0xf3, 0x29, 0x4e, 0x0c, 0xfe, 0x07, 0x58, + 0x18, 0x10, 0xb6, 0x4b, 0x59, 0x88, 0x23, 0x97, 0x24, 0xe8, 0x53, 0xaf, 0x81, 0x8e, 0x32, 0x40, + 0x99, 0xb9, 0x7b, 0x24, 0x20, 0x3d, 0xac, 0x96, 0x34, 0x46, 0x2f, 0xbc, 0xce, 0xdc, 0x53, 0x9c, + 0x18, 0xfc, 0x3d, 0x98, 0xc5, 0x5a, 0xeb, 0x0c, 0x18, 0xd9, 0xf5, 0x0f, 0xac, 0xa2, 0xda, 0x90, + 0x19, 0x23, 0xdd, 0x52, 0x42, 0x54, 0x83, 0x72, 0x40, 0x5d, 0x1c, 0x38, 0x1e, 0x89, 0x68, 0x68, + 0x4d, 0x2b, 0x1b, 0x50, 0xa2, 0x75, 0x29, 0x41, 0xb7, 0x00, 0x64, 0xb6, 0x19, 0x7d, 0x49, 0xe9, + 0x4b, 0x52, 0xa2, 0xd5, 0x04, 0xaa, 0x8c, 0x78, 0x24, 0x1c, 0xa8, 0x6f, 0x60, 0x58, 0x10, 0x0b, + 0xa4, 0x4d, 0xe7, 0x97, 0xdf, 0x1d, 0xd5, 0xae, 0xfc, 0xeb, 0xa8, 0xf6, 0x7e, 0xcf, 0x17, 0xfd, + 0x61, 0xb7, 0xe5, 0xd2, 0xd0, 0x24, 0xa4, 0xf9, 0xb3, 0xcc, 0xbd, 0x47, 0x6d, 0x71, 0x38, 0x20, + 0xbc, 0xb5, 0x4e, 0xdc, 0x67, 0x4f, 0x97, 0xc1, 0xe4, 0xeb, 0x3a, 0x71, 0xed, 0xd9, 0x14, 0xd4, + 0xc6, 0x82, 0xa0, 0x08, 0x16, 0x03, 0xcc, 0x85, 0x73, 0x3a, 0x56, 0x79, 0x0c, 0xb1, 0x90, 0x44, + 0xb6, 0x4f, 0xc6, 0xfb, 0x0d, 0xc0, 0x1e, 0x0e, 0x7c, 0x0f, 0x0b, 0xca, 0xb8, 0x55, 0xa9, 0x4f, + 0x34, 0xcb, 0x77, 0x6f, 0x8f, 0xde, 0x92, 0xdf, 0xc5, 0x3e, 0x76, 0xc6, 0x1d, 0x31, 0x98, 0xc3, + 0xbd, 0x1e, 0x93, 0x1b, 0x44, 0x1c, 0xe9, 0x17, 0x09, 0x6b, 0x46, 0x41, 0xae, 0x5c, 0x02, 0x72, + 0x43, 0x39, 0x76, 0x16, 0xbf, 0x7d, 0x5e, 0x9b, 0x3b, 0x25, 0xe4, 0x76, 0x35, 0x09, 0xa0, 0x25, + 0x72, 0xdb, 0xc2, 0x61, 0x20, 0x7c, 0x87, 0x93, 0xc8, 0xb3, 0x66, 0xeb, 0xb9, 0xe6, 0xb4, 0x5d, + 0x52, 0x92, 0x6d, 0x12, 0x79, 0xe8, 0x67, 0x30, 0x17, 0xf8, 0x8f, 0x87, 0xbe, 0xe7, 0x8b, 0x43, + 0x27, 0xa4, 0xde, 0x30, 0x20, 0x56, 0x55, 0x19, 0x55, 0x13, 0xf9, 0x03, 0x25, 0x46, 0x2b, 0xb0, + 0x98, 0x39, 0x61, 0xfb, 0xd8, 0x17, 0x3d, 0x46, 0x87, 0x03, 0x6b, 0xae, 0x9e, 0x6b, 0xce, 0xd8, + 0x0b, 0xa9, 0xee, 0x8b, 0x58, 0x85, 0x7e, 0x0e, 0x96, 0xdf, 0x75, 0x9d, 0x88, 0x1c, 0x08, 0x27, + 0x5d, 0x07, 0xa7, 0x8f, 0x79, 0xdf, 0x9a, 0xaf, 0xe7, 0x9a, 0x15, 0xfb, 0xaa, 0xdf, 0x75, 0x37, + 0xc9, 0x81, 0x48, 0x3e, 0x84, 0x7f, 0x8a, 0x79, 0x1f, 0x1d, 0xc2, 0x52, 0x62, 0xef, 0x70, 0x12, + 0x98, 0x6a, 0x83, 0x03, 0x99, 0x90, 0xf2, 0xa7, 0x85, 0xea, 0xb9, 0xe6, 0x64, 0xe7, 0xc3, 0xe3, + 0xa3, 0x5a, 0xfb, 0xd5, 0x96, 0x77, 0xb8, 0x60, 0x7e, 0xd4, 0xbb, 0x43, 0x43, 0x5f, 0xc8, 0x9d, + 0x3d, 0xb4, 0x6f, 0x26, 0x0e, 0xdb, 0xb1, 0xfd, 0x6a, 0x62, 0x8e, 0x7e, 0x0f, 0x0b, 0x7d, 0x1a, + 0x78, 0x7e, 0xd4, 0xe3, 0xd9, 0x78, 0x0b, 0x2a, 0x5e, 0xf3, 0xf8, 0xa8, 0xf6, 0xee, 0x39, 0xea, + 0xb3, 0x41, 0x50, 0x6c, 0x95, 0x81, 0xb6, 0x61, 0x5e, 0x25, 0x2f, 0x19, 0x50, 0xb7, 0xef, 0xf4, + 0x89, 0xdf, 0xeb, 0x0b, 0x6b, 0xb1, 0x9e, 0x6b, 0x4e, 0x74, 0xde, 0x3f, 0x3e, 0xaa, 0x35, 0xce, + 0x28, 0xcf, 0xc2, 0x56, 0xa5, 0xcd, 0x7d, 0x69, 0xf2, 0xa9, 0xb2, 0x40, 0x9b, 0x30, 0x21, 0xf6, + 0x02, 0xeb, 0xea, 0x18, 0xf2, 0x5f, 0x02, 0xa1, 0x2d, 0x98, 0x1b, 0x46, 0x5d, 0x1a, 0xc9, 0xb9, + 0x3b, 0x03, 0xc2, 0x7c, 0xea, 0x59, 0x6f, 0xa9, 0x29, 0xbe, 0x77, 0x7c, 0x54, 0x7b, 0xe7, 0xb4, + 0xee, 0x9c, 0x19, 0x26, 0x26, 0x5b, 0xca, 0x02, 0x7d, 0x06, 0xd5, 0x90, 0x70, 0x8e, 0x7b, 0x84, + 0x4b, 0x27, 0x47, 0x1c, 0x58, 0x6f, 0x2b, 0xc0, 0x77, 0x8f, 0x8f, 0x6a, 0xf5, 0x53, 0xaa, 0xb3, + 0x78, 0x33, 0xb1, 0xc5, 0x16, 0x61, 0x3b, 0x07, 0xe8, 0x17, 0x30, 0xed, 0x11, 0xd7, 0x0f, 0x71, + 0xc0, 0x2d, 0x4b, 0xc1, 0xdc, 0x3a, 0x3e, 0xaa, 0x5d, 0x8b, 0x65, 0x67, 0xfd, 0x13, 0x73, 0x74, + 0x1b, 0xe6, 0xd3, 0xe9, 0x93, 0x08, 0x77, 0x03, 0xe2, 0x59, 0xd7, 0x54, 0xb2, 0xa7, 0xdf, 0x7c, + 0x5f, 0xcb, 0xe5, 0xc1, 0x30, 0x1d, 0x86, 0x27, 0xb6, 0xd7, 0xf5, 0xc1, 0x88, 0xe5, 0xb1, 0x69, + 0x13, 0xe6, 0x18, 0x11, 0x43, 0x16, 0x39, 0x82, 0xaa, 0x63, 0x46, 0x98, 0x75, 0x43, 0x99, 0xce, + 0x6a, 0xf9, 0x0e, 0xdd, 0x56, 0x52, 0x74, 0x15, 0x0a, 0x3e, 0x77, 0x56, 0x56, 0xee, 0x59, 0x37, + 0x95, 0x7e, 0xca, 0xe7, 0x2b, 0x2b, 0xf7, 0xd0, 0x6f, 0xa1, 0xcc, 0x87, 0xdd, 0x27, 0x34, 0x22, + 0x1b, 0xd1, 0x2e, 0xb5, 0x6e, 0xa9, 0xc2, 0xbf, 0x3c, 0xba, 0x24, 0x6c, 0xa7, 0x4e, 0x76, 0x16, + 0x01, 0xb9, 0x30, 0xeb, 0x0d, 0xb9, 0x70, 0x44, 0x9f, 0x11, 0x2e, 0x13, 0xd1, 0x5a, 0xba, 0x74, + 0x7e, 0x6c, 0x44, 0x22, 0x93, 0x1f, 0x1b, 0x91, 0xb0, 0x67, 0x24, 0xe6, 0x4e, 0x0c, 0x29, 0x57, + 0x48, 0x30, 0x1c, 0xf1, 0x5d, 0xc2, 0x1c, 0xb7, 0x8f, 0xa3, 0x88, 0x04, 0x56, 0x4d, 0xb5, 0x85, + 0x6a, 0x2c, 0x5f, 0xd3, 0xe2, 0xc6, 0x26, 0x94, 0x33, 0x73, 0x45, 0x37, 0xa1, 0x84, 0x87, 0xa2, + 0x4f, 0x99, 0x2f, 0x0e, 0x0d, 0x7d, 0x48, 0x05, 0xe8, 0x1d, 0xa8, 0xa8, 0x46, 0xa3, 0x09, 0xc3, + 0xba, 0xe1, 0x0f, 0x65, 0x29, 0x5b, 0xd3, 0xa2, 0xc6, 0x5f, 0xf3, 0x50, 0xfc, 0x8c, 0x87, 0x6b, + 0x78, 0xc0, 0x11, 0x86, 0x99, 0xb4, 0x00, 0xb8, 0x78, 0xa0, 0x01, 0xdf, 0xf0, 0x28, 0x54, 0x12, + 0xc8, 0x35, 0x3c, 0x40, 0x5f, 0x01, 0x4a, 0x43, 0xc8, 0x3c, 0x51, 0x71, 0xf2, 0x63, 0x88, 0x33, + 0x97, 0xe0, 0x76, 0x68, 0xe4, 0xc9, 0x58, 0x0f, 0x01, 0x7a, 0x01, 0xed, 0xe2, 0x40, 0xc5, 0x98, + 0x18, 0x43, 0x8c, 0x92, 0xc6, 0x5b, 0xc3, 0x83, 0xc6, 0x9f, 0xf2, 0x00, 0x29, 0x5b, 0x40, 0x77, + 0xa1, 0x18, 0x93, 0x0d, 0xbd, 0x68, 0xd6, 0xb3, 0xa7, 0xcb, 0x8b, 0xc6, 0xd5, 0xf0, 0x87, 0x6d, + 0x75, 0x9e, 0xec, 0xd8, 0x10, 0x11, 0x28, 0x76, 0x71, 0x20, 0xd9, 0x8b, 0x95, 0x57, 0xad, 0xeb, + 0x5a, 0xcb, 0x38, 0xc8, 0x0d, 0x6a, 0x19, 0x2e, 0xda, 0x5a, 0xa3, 0x7e, 0xd4, 0xf9, 0x40, 0xce, + 0xfb, 0xdb, 0xe7, 0xb5, 0xe6, 0x05, 0xe6, 0x2d, 0x1d, 0xb8, 0x1d, 0x63, 0xa3, 0x1b, 0x50, 0x1a, + 0x50, 0x26, 0x9c, 0x08, 0x87, 0x44, 0xaf, 0x82, 0x3d, 0x2d, 0x05, 0x9b, 0x38, 0x24, 0x68, 0xf9, + 0x07, 0xb9, 0x5e, 0xe9, 0x3c, 0xf6, 0x76, 0x1b, 0xe6, 0x0d, 0x6c, 0xa6, 0x6b, 0x4d, 0xa9, 0xae, + 0x35, 0x67, 0x14, 0x49, 0xcb, 0x6a, 0xfc, 0x31, 0x07, 0x95, 0x75, 0x5f, 0x56, 0x91, 0xee, 0x50, + 0x15, 0x6d, 0x0b, 0x8a, 0x7b, 0x38, 0xa0, 0x03, 0xc2, 0x4c, 0xaa, 0xc6, 0x43, 0x74, 0x03, 0x8a, + 0x0e, 0x0e, 0xe5, 0x4a, 0xaa, 0x5c, 0x98, 0xec, 0xe4, 0xad, 0x9c, 0x5d, 0x58, 0x55, 0x12, 0xb4, + 0x03, 0x05, 0xa3, 0x9b, 0x18, 0xc3, 0xd1, 0x33, 0x58, 0x8d, 0x7f, 0x4c, 0xc1, 0xdc, 0x17, 0xc9, + 0x07, 0xda, 0xc4, 0xa5, 0xec, 0x24, 0xd9, 0xce, 0x9d, 0x24, 0xdb, 0x1f, 0x41, 0xc9, 0x30, 0x42, + 0xca, 0x4c, 0xc2, 0xfe, 0xf0, 0x1e, 0xa7, 0xa6, 0xc8, 0x86, 0x8a, 0x97, 0x59, 0x04, 0x6b, 0x42, + 0x6d, 0x75, 0x6b, 0x74, 0x49, 0xca, 0x2e, 0x9d, 0x7d, 0x02, 0x43, 0xce, 0x85, 0x11, 0xd7, 0x1f, + 0xf8, 0x92, 0xf6, 0x4c, 0x8e, 0x9a, 0x4b, 0x62, 0x8a, 0xdc, 0x64, 0x25, 0xa7, 0xc6, 0x9f, 0x70, + 0x06, 0x1a, 0x3d, 0x81, 0x72, 0x57, 0x56, 0x70, 0x13, 0x49, 0x73, 0xef, 0x57, 0x44, 0xfa, 0x95, + 0xd9, 0xce, 0x9f, 0x5e, 0x30, 0xd2, 0xb3, 0xa7, 0xcb, 0x65, 0x03, 0x26, 0x87, 0x36, 0xc8, 0x68, + 0x26, 0x55, 0xde, 0x82, 0x82, 0x38, 0x50, 0x9c, 0x48, 0x33, 0x73, 0x33, 0x92, 0x72, 0x2e, 0xb0, + 0x18, 0x72, 0xc5, 0xc6, 0xa7, 0x6c, 0x33, 0x42, 0x0f, 0xa0, 0xea, 0xd2, 0x70, 0x10, 0x10, 0xc5, + 0x74, 0xe4, 0x45, 0x4d, 0xd1, 0xf1, 0xf2, 0xdd, 0xeb, 0x2d, 0x7d, 0x8b, 0x6b, 0xc5, 0xb7, 0xb8, + 0xd6, 0x4e, 0x7c, 0x8b, 0xeb, 0x4c, 0xcb, 0x09, 0x7f, 0xf3, 0xbc, 0x96, 0xb3, 0x67, 0x53, 0x67, + 0xa9, 0x46, 0xd7, 0x61, 0x9a, 0x91, 0xc7, 0x43, 0x32, 0x24, 0x9e, 0xa2, 0xec, 0xd3, 0x76, 0x32, + 0x46, 0x0d, 0xa8, 0x60, 0xf7, 0x51, 0x44, 0xf7, 0x03, 0xe2, 0xf5, 0x88, 0xa7, 0x68, 0xf6, 0xb4, + 0x7d, 0x42, 0x26, 0xeb, 0xb5, 0xe6, 0x2c, 0xd1, 0x30, 0xec, 0x12, 0x66, 0x55, 0x64, 0x57, 0xb6, + 0xcb, 0x4a, 0xb6, 0xa9, 0x44, 0xf2, 0x72, 0x21, 0xfb, 0xa2, 0x43, 0x18, 0x93, 0x34, 0x7a, 0x46, + 0x59, 0x80, 0x14, 0xdd, 0x57, 0x92, 0xc6, 0x9f, 0xf3, 0x50, 0xfd, 0x3c, 0x6e, 0xc1, 0xa3, 0xd3, + 0xfa, 0x74, 0xc8, 0xfc, 0xd9, 0x90, 0x1f, 0x41, 0x29, 0xa9, 0xad, 0xe6, 0x08, 0xbe, 0x22, 0xdb, + 0x12, 0x53, 0x79, 0x5d, 0x62, 0x24, 0xc0, 0x82, 0x78, 0x8e, 0xd9, 0x94, 0xc9, 0xfa, 0x84, 0xbc, + 0x2e, 0x19, 0xe9, 0x8e, 0xde, 0x9b, 0xc7, 0x99, 0xa4, 0xfc, 0x91, 0x53, 0x25, 0x3e, 0xfb, 0x5f, + 0x4f, 0x00, 0x92, 0xb7, 0x93, 0xf8, 0x82, 0x37, 0x96, 0x65, 0xfa, 0x00, 0x0a, 0x9c, 0x0e, 0x99, + 0x4b, 0x46, 0xae, 0x91, 0xb1, 0x43, 0x1f, 0x43, 0xd9, 0x23, 0x5c, 0xf8, 0x91, 0xe6, 0xc5, 0xa3, + 0x0e, 0x72, 0xd6, 0x38, 0x5b, 0x31, 0xa7, 0x14, 0x77, 0xcb, 0x56, 0xcc, 0x73, 0xd2, 0xba, 0xf0, + 0x06, 0x69, 0x9d, 0x16, 0xe0, 0xe2, 0x18, 0x0b, 0xf0, 0x51, 0x01, 0x4a, 0xc9, 0x5d, 0x05, 0xad, + 0x42, 0xd5, 0x34, 0x03, 0xe7, 0xa2, 0x8d, 0x74, 0xd6, 0x38, 0xac, 0x26, 0xfd, 0x54, 0x7e, 0x75, + 0xe8, 0x73, 0x9e, 0xdc, 0x65, 0xc7, 0x41, 0x2c, 0x66, 0x53, 0x50, 0x75, 0x8f, 0xed, 0x49, 0x3a, + 0x6b, 0xaa, 0xbb, 0xc3, 0xfb, 0x98, 0x11, 0x3e, 0x16, 0x72, 0x51, 0x4d, 0x50, 0xb7, 0x15, 0x28, + 0x72, 0xa0, 0xb2, 0x47, 0x85, 0xba, 0x20, 0xd0, 0x7d, 0xc2, 0x4c, 0x7e, 0xbc, 0xd9, 0xe2, 0x97, + 0x35, 0xe2, 0x96, 0x04, 0x44, 0x36, 0x4c, 0x71, 0x97, 0x32, 0xa2, 0x32, 0xe8, 0x4d, 0xa7, 0xaf, + 0xa1, 0x32, 0x95, 0xb6, 0xa0, 0x2b, 0xb0, 0xa9, 0xb4, 0x6f, 0x41, 0xe1, 0x2b, 0xec, 0x4b, 0xea, + 0x5f, 0x54, 0x85, 0xcf, 0x8c, 0xd0, 0x12, 0x80, 0xa0, 0x61, 0x97, 0x0b, 0x1a, 0x11, 0x4f, 0x55, + 0xe7, 0x69, 0x3b, 0x23, 0x41, 0x9f, 0x40, 0x45, 0x5b, 0x3a, 0xdc, 0x97, 0x4c, 0xe9, 0x32, 0xe5, + 0xb9, 0xac, 0x3d, 0xb7, 0xa5, 0x23, 0xfa, 0x3a, 0x07, 0x57, 0x4f, 0x51, 0x4f, 0xb3, 0x79, 0xfa, + 0x71, 0x65, 0xf3, 0x72, 0x5f, 0xff, 0xdf, 0xa3, 0xda, 0xcd, 0x43, 0x1c, 0x06, 0x1f, 0x37, 0xce, + 0x05, 0x6d, 0xd8, 0x0b, 0x27, 0xf8, 0xa8, 0xd9, 0xd2, 0x47, 0x30, 0xa3, 0xdf, 0x02, 0xe2, 0xd8, + 0xfa, 0xb1, 0xe5, 0xd7, 0x97, 0x8e, 0xbd, 0xa8, 0x63, 0x9f, 0x00, 0x6b, 0xd8, 0x15, 0x3d, 0xd6, + 0xc1, 0x1a, 0x7f, 0xc9, 0x41, 0x75, 0x3d, 0xce, 0x29, 0xf3, 0x86, 0x71, 0x82, 0xc5, 0xe4, 0x2e, + 0xce, 0x62, 0x30, 0x14, 0xf5, 0x2b, 0x0b, 0x37, 0x5c, 0x75, 0x6c, 0xcf, 0x2c, 0x31, 0x6e, 0xe3, + 0xef, 0x39, 0xa8, 0x9e, 0xd2, 0xa2, 0xce, 0xe5, 0xab, 0xc2, 0x69, 0x07, 0x44, 0xa0, 0xb0, 0xaf, + 0xdf, 0x07, 0x74, 0x35, 0x78, 0x70, 0xe9, 0xc5, 0x9e, 0xd1, 0x8b, 0xad, 0x51, 0x1a, 0xa7, 0xf2, + 0xbe, 0x10, 0x8b, 0xf3, 0x00, 0xeb, 0x49, 0x47, 0x41, 0x9f, 0x9c, 0xfb, 0x10, 0x39, 0x6a, 0xf2, + 0xe7, 0x3c, 0x3a, 0xde, 0x87, 0xf9, 0x34, 0xc3, 0x62, 0x9c, 0x51, 0xfc, 0x33, 0xbd, 0x0c, 0xc5, + 0x30, 0x8f, 0x4f, 0x90, 0xe8, 0xff, 0x47, 0x97, 0x95, 0x47, 0xde, 0x3c, 0xcc, 0x4c, 0xaa, 0x6e, + 0x69, 0x46, 0xf2, 0xb6, 0xcb, 0x32, 0xcd, 0xd7, 0x21, 0x91, 0xa7, 0x7b, 0x98, 0x5d, 0xcd, 0xca, + 0xef, 0x47, 0x5e, 0x63, 0x1b, 0x16, 0xb6, 0x28, 0x13, 0x6b, 0xc9, 0x83, 0xf8, 0xce, 0x70, 0x10, + 0x5c, 0xf0, 0xe1, 0xfc, 0x6d, 0x28, 0xaa, 0x7b, 0x4f, 0xf2, 0x6e, 0x5e, 0x90, 0xc3, 0x0d, 0xaf, + 0xf1, 0xef, 0x3c, 0x14, 0x6d, 0xe2, 0x12, 0x7f, 0x20, 0x5e, 0xd5, 0xf2, 0x65, 0x3f, 0xd7, 0x2f, + 0x10, 0xf9, 0x91, 0xfd, 0x5c, 0xbf, 0x49, 0xa4, 0xec, 0x73, 0xe2, 0x04, 0xfb, 0x4c, 0x69, 0xf7, + 0xe4, 0x8f, 0x47, 0xbb, 0xd7, 0x00, 0x76, 0x7d, 0xc6, 0x85, 0xc3, 0x09, 0x89, 0x0c, 0x95, 0x1a, + 0x55, 0x26, 0x73, 0xaa, 0x4c, 0x96, 0x94, 0xdf, 0x36, 0x21, 0x11, 0xea, 0x40, 0xc9, 0xf4, 0x7e, + 0xe2, 0x5d, 0x90, 0x32, 0x18, 0x8c, 0xc4, 0xad, 0xf3, 0xf0, 0xbb, 0x17, 0x4b, 0xb9, 0xef, 0x5f, + 0x2c, 0xe5, 0xfe, 0xf3, 0x62, 0x29, 0xf7, 0xcd, 0xcb, 0xa5, 0x2b, 0xdf, 0xbf, 0x5c, 0xba, 0xf2, + 0xcf, 0x97, 0x4b, 0x57, 0xbe, 0x5c, 0xcd, 0x7c, 0x54, 0xa6, 0x7a, 0x2c, 0x3f, 0xa1, 0x11, 0xc9, + 0x0a, 0xda, 0x07, 0xe7, 0xfc, 0x93, 0x47, 0x7d, 0x73, 0xb7, 0xa0, 0x66, 0xf1, 0xe1, 0xff, 0x02, + 0x00, 0x00, 0xff, 0xff, 0xea, 0x14, 0x88, 0x5a, 0x12, 0x1a, 0x00, 0x00, } func (m *Zone) Marshal() (dAtA []byte, err error) { @@ -1876,6 +1885,11 @@ func (m *WithdrawalRecord) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if m.SendErrors != 0 { + i = encodeVarintInterchainstaking(dAtA, i, uint64(m.SendErrors)) + i-- + dAtA[i] = 0x68 + } if m.EpochNumber != 0 { i = encodeVarintInterchainstaking(dAtA, i, uint64(m.EpochNumber)) i-- @@ -2754,6 +2768,9 @@ func (m *WithdrawalRecord) Size() (n int) { if m.EpochNumber != 0 { n += 1 + sovInterchainstaking(uint64(m.EpochNumber)) } + if m.SendErrors != 0 { + n += 1 + sovInterchainstaking(uint64(m.SendErrors)) + } return n } @@ -4852,6 +4869,25 @@ func (m *WithdrawalRecord) Unmarshal(dAtA []byte) error { break } } + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SendErrors", wireType) + } + m.SendErrors = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowInterchainstaking + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.SendErrors |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } default: iNdEx = preIndex skippy, err := skipInterchainstaking(dAtA[iNdEx:]) diff --git a/x/interchainstaking/types/messages.pb.go b/x/interchainstaking/types/messages.pb.go index 5ff9225ec..832e56a69 100644 --- a/x/interchainstaking/types/messages.pb.go +++ b/x/interchainstaking/types/messages.pb.go @@ -109,25 +109,25 @@ func (m *MsgRequestRedemptionResponse) XXX_DiscardUnknown() { var xxx_messageInfo_MsgRequestRedemptionResponse proto.InternalMessageInfo -// MsgCancelQueuedRedemption represents a message type to cancel . -type MsgCancelQueuedRedemption struct { +// MsgCancelRedemption represents a message type to cancel . +type MsgCancelRedemption struct { ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` Hash string `protobuf:"bytes,2,opt,name=hash,proto3" json:"hash,omitempty"` FromAddress string `protobuf:"bytes,3,opt,name=from_address,json=fromAddress,proto3" json:"from_address,omitempty"` } -func (m *MsgCancelQueuedRedemption) Reset() { *m = MsgCancelQueuedRedemption{} } -func (m *MsgCancelQueuedRedemption) String() string { return proto.CompactTextString(m) } -func (*MsgCancelQueuedRedemption) ProtoMessage() {} -func (*MsgCancelQueuedRedemption) Descriptor() ([]byte, []int) { +func (m *MsgCancelRedemption) Reset() { *m = MsgCancelRedemption{} } +func (m *MsgCancelRedemption) String() string { return proto.CompactTextString(m) } +func (*MsgCancelRedemption) ProtoMessage() {} +func (*MsgCancelRedemption) Descriptor() ([]byte, []int) { return fileDescriptor_ee484030fa140a82, []int{2} } -func (m *MsgCancelQueuedRedemption) XXX_Unmarshal(b []byte) error { +func (m *MsgCancelRedemption) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *MsgCancelQueuedRedemption) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *MsgCancelRedemption) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_MsgCancelQueuedRedemption.Marshal(b, m, deterministic) + return xxx_messageInfo_MsgCancelRedemption.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -137,35 +137,35 @@ func (m *MsgCancelQueuedRedemption) XXX_Marshal(b []byte, deterministic bool) ([ return b[:n], nil } } -func (m *MsgCancelQueuedRedemption) XXX_Merge(src proto.Message) { - xxx_messageInfo_MsgCancelQueuedRedemption.Merge(m, src) +func (m *MsgCancelRedemption) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgCancelRedemption.Merge(m, src) } -func (m *MsgCancelQueuedRedemption) XXX_Size() int { +func (m *MsgCancelRedemption) XXX_Size() int { return m.Size() } -func (m *MsgCancelQueuedRedemption) XXX_DiscardUnknown() { - xxx_messageInfo_MsgCancelQueuedRedemption.DiscardUnknown(m) +func (m *MsgCancelRedemption) XXX_DiscardUnknown() { + xxx_messageInfo_MsgCancelRedemption.DiscardUnknown(m) } -var xxx_messageInfo_MsgCancelQueuedRedemption proto.InternalMessageInfo +var xxx_messageInfo_MsgCancelRedemption proto.InternalMessageInfo -// MsgRequestRedemptionResponse defines the MsgRequestRedemption response type. -type MsgCancelQueuedRedemptionResponse struct { +// MsgCancelRedemptionResponse defines the MsgCancelRedemption response type. +type MsgCancelRedemptionResponse struct { Returned types.Coin `protobuf:"bytes,1,opt,name=returned,proto3" json:"returned" yaml:"coin"` } -func (m *MsgCancelQueuedRedemptionResponse) Reset() { *m = MsgCancelQueuedRedemptionResponse{} } -func (m *MsgCancelQueuedRedemptionResponse) String() string { return proto.CompactTextString(m) } -func (*MsgCancelQueuedRedemptionResponse) ProtoMessage() {} -func (*MsgCancelQueuedRedemptionResponse) Descriptor() ([]byte, []int) { +func (m *MsgCancelRedemptionResponse) Reset() { *m = MsgCancelRedemptionResponse{} } +func (m *MsgCancelRedemptionResponse) String() string { return proto.CompactTextString(m) } +func (*MsgCancelRedemptionResponse) ProtoMessage() {} +func (*MsgCancelRedemptionResponse) Descriptor() ([]byte, []int) { return fileDescriptor_ee484030fa140a82, []int{3} } -func (m *MsgCancelQueuedRedemptionResponse) XXX_Unmarshal(b []byte) error { +func (m *MsgCancelRedemptionResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *MsgCancelQueuedRedemptionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *MsgCancelRedemptionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_MsgCancelQueuedRedemptionResponse.Marshal(b, m, deterministic) + return xxx_messageInfo_MsgCancelRedemptionResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -175,25 +175,180 @@ func (m *MsgCancelQueuedRedemptionResponse) XXX_Marshal(b []byte, deterministic return b[:n], nil } } -func (m *MsgCancelQueuedRedemptionResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_MsgCancelQueuedRedemptionResponse.Merge(m, src) +func (m *MsgCancelRedemptionResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgCancelRedemptionResponse.Merge(m, src) } -func (m *MsgCancelQueuedRedemptionResponse) XXX_Size() int { +func (m *MsgCancelRedemptionResponse) XXX_Size() int { return m.Size() } -func (m *MsgCancelQueuedRedemptionResponse) XXX_DiscardUnknown() { - xxx_messageInfo_MsgCancelQueuedRedemptionResponse.DiscardUnknown(m) +func (m *MsgCancelRedemptionResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgCancelRedemptionResponse.DiscardUnknown(m) } -var xxx_messageInfo_MsgCancelQueuedRedemptionResponse proto.InternalMessageInfo +var xxx_messageInfo_MsgCancelRedemptionResponse proto.InternalMessageInfo -func (m *MsgCancelQueuedRedemptionResponse) GetReturned() types.Coin { +func (m *MsgCancelRedemptionResponse) GetReturned() types.Coin { if m != nil { return m.Returned } return types.Coin{} } +// MsgUpdateRedemption represents a message type to update a redemption. +type MsgUpdateRedemption struct { + ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` + Hash string `protobuf:"bytes,2,opt,name=hash,proto3" json:"hash,omitempty"` + NewStatus int32 `protobuf:"varint,3,opt,name=new_status,json=newStatus,proto3" json:"new_status,omitempty"` + FromAddress string `protobuf:"bytes,4,opt,name=from_address,json=fromAddress,proto3" json:"from_address,omitempty"` +} + +func (m *MsgUpdateRedemption) Reset() { *m = MsgUpdateRedemption{} } +func (m *MsgUpdateRedemption) String() string { return proto.CompactTextString(m) } +func (*MsgUpdateRedemption) ProtoMessage() {} +func (*MsgUpdateRedemption) Descriptor() ([]byte, []int) { + return fileDescriptor_ee484030fa140a82, []int{4} +} +func (m *MsgUpdateRedemption) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgUpdateRedemption) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgUpdateRedemption.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *MsgUpdateRedemption) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgUpdateRedemption.Merge(m, src) +} +func (m *MsgUpdateRedemption) XXX_Size() int { + return m.Size() +} +func (m *MsgUpdateRedemption) XXX_DiscardUnknown() { + xxx_messageInfo_MsgUpdateRedemption.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgUpdateRedemption proto.InternalMessageInfo + +// MsgUpdateRedemptionResponse defines the MsgUpdateRedemption response type. +type MsgUpdateRedemptionResponse struct { +} + +func (m *MsgUpdateRedemptionResponse) Reset() { *m = MsgUpdateRedemptionResponse{} } +func (m *MsgUpdateRedemptionResponse) String() string { return proto.CompactTextString(m) } +func (*MsgUpdateRedemptionResponse) ProtoMessage() {} +func (*MsgUpdateRedemptionResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_ee484030fa140a82, []int{5} +} +func (m *MsgUpdateRedemptionResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgUpdateRedemptionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgUpdateRedemptionResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *MsgUpdateRedemptionResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgUpdateRedemptionResponse.Merge(m, src) +} +func (m *MsgUpdateRedemptionResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgUpdateRedemptionResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgUpdateRedemptionResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgUpdateRedemptionResponse proto.InternalMessageInfo + +// MsgRequeueRedemption represents a message type to requeue. +type MsgRequeueRedemption struct { + ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` + Hash string `protobuf:"bytes,2,opt,name=hash,proto3" json:"hash,omitempty"` + FromAddress string `protobuf:"bytes,3,opt,name=from_address,json=fromAddress,proto3" json:"from_address,omitempty"` +} + +func (m *MsgRequeueRedemption) Reset() { *m = MsgRequeueRedemption{} } +func (m *MsgRequeueRedemption) String() string { return proto.CompactTextString(m) } +func (*MsgRequeueRedemption) ProtoMessage() {} +func (*MsgRequeueRedemption) Descriptor() ([]byte, []int) { + return fileDescriptor_ee484030fa140a82, []int{6} +} +func (m *MsgRequeueRedemption) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgRequeueRedemption) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgRequeueRedemption.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *MsgRequeueRedemption) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgRequeueRedemption.Merge(m, src) +} +func (m *MsgRequeueRedemption) XXX_Size() int { + return m.Size() +} +func (m *MsgRequeueRedemption) XXX_DiscardUnknown() { + xxx_messageInfo_MsgRequeueRedemption.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgRequeueRedemption proto.InternalMessageInfo + +// MsgRequeueRedemptionResponse defines the MsgRequeueRedemption response type. +type MsgRequeueRedemptionResponse struct { +} + +func (m *MsgRequeueRedemptionResponse) Reset() { *m = MsgRequeueRedemptionResponse{} } +func (m *MsgRequeueRedemptionResponse) String() string { return proto.CompactTextString(m) } +func (*MsgRequeueRedemptionResponse) ProtoMessage() {} +func (*MsgRequeueRedemptionResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_ee484030fa140a82, []int{7} +} +func (m *MsgRequeueRedemptionResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgRequeueRedemptionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgRequeueRedemptionResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *MsgRequeueRedemptionResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgRequeueRedemptionResponse.Merge(m, src) +} +func (m *MsgRequeueRedemptionResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgRequeueRedemptionResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgRequeueRedemptionResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgRequeueRedemptionResponse proto.InternalMessageInfo + // MsgSignalIntent represents a message type for signalling voting intent for // one or more validators. type MsgSignalIntent struct { @@ -206,7 +361,7 @@ func (m *MsgSignalIntent) Reset() { *m = MsgSignalIntent{} } func (m *MsgSignalIntent) String() string { return proto.CompactTextString(m) } func (*MsgSignalIntent) ProtoMessage() {} func (*MsgSignalIntent) Descriptor() ([]byte, []int) { - return fileDescriptor_ee484030fa140a82, []int{4} + return fileDescriptor_ee484030fa140a82, []int{8} } func (m *MsgSignalIntent) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -243,7 +398,7 @@ func (m *MsgSignalIntentResponse) Reset() { *m = MsgSignalIntentResponse func (m *MsgSignalIntentResponse) String() string { return proto.CompactTextString(m) } func (*MsgSignalIntentResponse) ProtoMessage() {} func (*MsgSignalIntentResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_ee484030fa140a82, []int{5} + return fileDescriptor_ee484030fa140a82, []int{9} } func (m *MsgSignalIntentResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -275,8 +430,12 @@ var xxx_messageInfo_MsgSignalIntentResponse proto.InternalMessageInfo func init() { proto.RegisterType((*MsgRequestRedemption)(nil), "quicksilver.interchainstaking.v1.MsgRequestRedemption") proto.RegisterType((*MsgRequestRedemptionResponse)(nil), "quicksilver.interchainstaking.v1.MsgRequestRedemptionResponse") - proto.RegisterType((*MsgCancelQueuedRedemption)(nil), "quicksilver.interchainstaking.v1.MsgCancelQueuedRedemption") - proto.RegisterType((*MsgCancelQueuedRedemptionResponse)(nil), "quicksilver.interchainstaking.v1.MsgCancelQueuedRedemptionResponse") + proto.RegisterType((*MsgCancelRedemption)(nil), "quicksilver.interchainstaking.v1.MsgCancelRedemption") + proto.RegisterType((*MsgCancelRedemptionResponse)(nil), "quicksilver.interchainstaking.v1.MsgCancelRedemptionResponse") + proto.RegisterType((*MsgUpdateRedemption)(nil), "quicksilver.interchainstaking.v1.MsgUpdateRedemption") + proto.RegisterType((*MsgUpdateRedemptionResponse)(nil), "quicksilver.interchainstaking.v1.MsgUpdateRedemptionResponse") + proto.RegisterType((*MsgRequeueRedemption)(nil), "quicksilver.interchainstaking.v1.MsgRequeueRedemption") + proto.RegisterType((*MsgRequeueRedemptionResponse)(nil), "quicksilver.interchainstaking.v1.MsgRequeueRedemptionResponse") proto.RegisterType((*MsgSignalIntent)(nil), "quicksilver.interchainstaking.v1.MsgSignalIntent") proto.RegisterType((*MsgSignalIntentResponse)(nil), "quicksilver.interchainstaking.v1.MsgSignalIntentResponse") } @@ -286,61 +445,67 @@ func init() { } var fileDescriptor_ee484030fa140a82 = []byte{ - // 851 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x96, 0x4f, 0x6f, 0x1b, 0x45, - 0x18, 0xc6, 0x3d, 0x2d, 0xd0, 0x74, 0xd2, 0x92, 0x32, 0x89, 0xd4, 0x78, 0x55, 0xad, 0xc3, 0x9e, - 0x2a, 0xa0, 0xbb, 0x75, 0x0a, 0x01, 0x12, 0x1a, 0x48, 0x1c, 0x61, 0x19, 0xd5, 0x07, 0x36, 0x12, - 0x07, 0x38, 0x58, 0xe3, 0xdd, 0x97, 0xf5, 0xa8, 0xbb, 0x33, 0xdb, 0x9d, 0xf1, 0xaa, 0xe6, 0xc8, - 0x89, 0x03, 0x07, 0x10, 0x5f, 0xa0, 0x1f, 0xa2, 0xe2, 0xca, 0x01, 0x0e, 0x39, 0x56, 0x70, 0x80, - 0x93, 0x85, 0x12, 0x90, 0x38, 0x21, 0x91, 0x4f, 0x80, 0xf6, 0x8f, 0x37, 0x76, 0xec, 0x2a, 0x5b, - 0x27, 0xb7, 0xdd, 0x7d, 0xe7, 0x79, 0xe6, 0xf9, 0xbd, 0xf3, 0x8e, 0x65, 0x6c, 0x3d, 0xea, 0x33, - 0xe7, 0xa1, 0x64, 0x7e, 0x0c, 0x91, 0xc5, 0xb8, 0x82, 0xc8, 0xe9, 0x51, 0xc6, 0xa5, 0xa2, 0x0f, - 0x19, 0xf7, 0xac, 0xb8, 0x6e, 0x05, 0x20, 0x25, 0xf5, 0x40, 0x9a, 0x61, 0x24, 0x94, 0x20, 0x6b, - 0x63, 0x02, 0x73, 0x4a, 0x60, 0xc6, 0x75, 0x4d, 0x77, 0x84, 0x0c, 0x84, 0xb4, 0xba, 0x54, 0x82, - 0x15, 0xd7, 0xbb, 0xa0, 0x68, 0xdd, 0x72, 0x04, 0xe3, 0x99, 0x83, 0x56, 0xcd, 0xea, 0x9d, 0xf4, - 0xcd, 0xca, 0x5e, 0xf2, 0xd2, 0x8a, 0x27, 0x3c, 0x91, 0x7d, 0x4f, 0x9e, 0xf2, 0xaf, 0xb7, 0x3c, - 0x21, 0x3c, 0x1f, 0x2c, 0x1a, 0x32, 0x8b, 0x72, 0x2e, 0x14, 0x55, 0x4c, 0xf0, 0x91, 0xe6, 0xee, - 0x99, 0x04, 0x61, 0x24, 0x42, 0x21, 0xa9, 0x9f, 0x2b, 0x8c, 0x7f, 0x11, 0x5e, 0x69, 0x4b, 0xcf, - 0x86, 0x47, 0x7d, 0x90, 0xca, 0x06, 0x17, 0x82, 0x30, 0x71, 0x24, 0x7b, 0xf8, 0xe5, 0x98, 0xfa, - 0x7d, 0x58, 0x45, 0x6b, 0xe8, 0xf6, 0xe2, 0x7a, 0xd5, 0xcc, 0xc3, 0x25, 0x24, 0x66, 0x4e, 0x62, - 0x36, 0x04, 0xe3, 0xbb, 0xcb, 0x07, 0xc3, 0x5a, 0xe5, 0x78, 0x58, 0x5b, 0x1c, 0xd0, 0xc0, 0xdf, - 0x34, 0x12, 0x3a, 0xc3, 0xce, 0xc4, 0xa4, 0x85, 0x97, 0x5d, 0x90, 0x8a, 0xf1, 0x34, 0x66, 0x87, - 0xba, 0x6e, 0x04, 0x52, 0xae, 0x5e, 0x5a, 0x43, 0xb7, 0xaf, 0xee, 0xae, 0xfe, 0xfa, 0xf4, 0xce, - 0x4a, 0x6e, 0xbb, 0x93, 0x55, 0xf6, 0x55, 0xc4, 0xb8, 0x67, 0x93, 0x31, 0x51, 0x5e, 0x21, 0x5b, - 0xf8, 0xda, 0x97, 0x91, 0x08, 0x0a, 0x8f, 0xcb, 0x67, 0x78, 0x2c, 0x26, 0xab, 0xf3, 0x4f, 0x9b, - 0x0b, 0xdf, 0x3c, 0xa9, 0x55, 0xfe, 0x79, 0x52, 0xab, 0x18, 0x3a, 0xbe, 0x35, 0x8b, 0xd7, 0x06, - 0x19, 0x0a, 0x2e, 0xc1, 0xf8, 0x1e, 0xe1, 0x6a, 0x5b, 0x7a, 0x0d, 0xca, 0x1d, 0xf0, 0x3f, 0xed, - 0x43, 0x1f, 0xdc, 0xb1, 0xae, 0x54, 0xf1, 0x42, 0xda, 0xd1, 0x0e, 0x73, 0xd3, 0xc6, 0x5c, 0xb5, - 0xaf, 0xa4, 0xef, 0x2d, 0x97, 0x10, 0xfc, 0x52, 0x8f, 0xca, 0x5e, 0xc6, 0x66, 0xa7, 0xcf, 0x17, - 0x95, 0x59, 0xe0, 0xd7, 0x9f, 0x1b, 0x69, 0x14, 0x9c, 0x7c, 0x82, 0x17, 0x22, 0x50, 0xfd, 0x88, - 0x83, 0x3b, 0xe7, 0x99, 0x15, 0x7a, 0xe3, 0x47, 0x84, 0x97, 0xda, 0xd2, 0xdb, 0x67, 0x1e, 0xa7, - 0x7e, 0x8b, 0x2b, 0xe0, 0x8a, 0x98, 0xa7, 0xd1, 0x77, 0x97, 0x8f, 0x87, 0xb5, 0xa5, 0xdc, 0x20, - 0xaf, 0x18, 0x27, 0xfd, 0x78, 0x0b, 0x5f, 0x61, 0xa9, 0x72, 0x74, 0xdc, 0xe4, 0x78, 0x58, 0x7b, - 0x35, 0x5b, 0x9e, 0x17, 0x0c, 0x7b, 0xb4, 0xe4, 0xa2, 0x3a, 0x55, 0xc5, 0x37, 0x4f, 0xe5, 0x1e, - 0xf5, 0x67, 0xfd, 0xdb, 0xeb, 0xf8, 0x72, 0x5b, 0x7a, 0xe4, 0x67, 0x84, 0x5f, 0x9b, 0x1e, 0xf7, - 0x0d, 0xf3, 0xac, 0xbb, 0x6c, 0xce, 0x1a, 0x1b, 0x6d, 0x7b, 0x3e, 0x5d, 0x31, 0x6e, 0x1b, 0x5f, - 0xff, 0xf6, 0xd7, 0x0f, 0x97, 0xee, 0x6e, 0xa2, 0x37, 0x8c, 0x37, 0x27, 0x7e, 0x7f, 0xd4, 0xe3, - 0xe4, 0xba, 0x4e, 0xdf, 0xe1, 0x08, 0x5c, 0x80, 0x80, 0x3c, 0x45, 0xf8, 0xda, 0xc4, 0xf1, 0xd4, - 0x4b, 0x05, 0x19, 0x97, 0x68, 0xef, 0xbf, 0xb0, 0x64, 0xfe, 0xd8, 0xd9, 0x39, 0x93, 0xdf, 0x11, - 0xbe, 0x91, 0xcd, 0xf1, 0x58, 0xef, 0xb7, 0x4a, 0xe5, 0x98, 0x3d, 0xfe, 0x5a, 0xe3, 0x1c, 0xe2, - 0x02, 0x67, 0x27, 0xc5, 0xd9, 0x4a, 0x70, 0x36, 0x4a, 0xe1, 0x38, 0xa9, 0x5f, 0x27, 0x3a, 0x81, - 0xf8, 0x05, 0xe1, 0xa5, 0xa6, 0x88, 0x1b, 0xbe, 0x90, 0xd0, 0xe8, 0x51, 0xce, 0xc1, 0x27, 0x6f, - 0x97, 0xca, 0x76, 0x4a, 0xa5, 0x7d, 0x30, 0x8f, 0xaa, 0x40, 0xb9, 0x9f, 0xa2, 0xbc, 0x9b, 0xa0, - 0xac, 0x97, 0x43, 0x49, 0x5c, 0x3a, 0x4e, 0x1e, 0xf9, 0x00, 0xe1, 0x1b, 0x4d, 0x11, 0xdb, 0x20, - 0x42, 0xe0, 0x23, 0x8e, 0x77, 0xca, 0x26, 0x9a, 0x90, 0x69, 0xf7, 0xe7, 0x92, 0x15, 0x24, 0xdb, - 0x29, 0xc9, 0x7b, 0x09, 0xc9, 0xbd, 0x92, 0x57, 0x23, 0xb1, 0x29, 0x50, 0x7e, 0x42, 0xf8, 0x7a, - 0x53, 0xc4, 0xfb, 0xa0, 0x1e, 0xc8, 0xa0, 0x41, 0x43, 0x49, 0xd6, 0xcb, 0x06, 0x3a, 0xd1, 0x68, - 0x9b, 0x2f, 0xae, 0xb9, 0x30, 0x82, 0xbf, 0x11, 0xbe, 0xd9, 0x14, 0xf1, 0x8e, 0xeb, 0x7e, 0x46, - 0x7d, 0xe6, 0x52, 0x25, 0xa2, 0x3d, 0xe0, 0x83, 0x07, 0x4c, 0x2a, 0x52, 0x7a, 0x4a, 0x66, 0xa9, - 0xb5, 0xbd, 0xf3, 0xa8, 0x0b, 0xbe, 0x8f, 0x53, 0xbe, 0x8f, 0x12, 0xbe, 0xad, 0x52, 0x7c, 0xd4, - 0x75, 0x3b, 0xf1, 0xc8, 0xae, 0xe3, 0x02, 0x1f, 0xf8, 0x09, 0xcb, 0x7f, 0x08, 0x6b, 0xe9, 0x18, - 0x04, 0x22, 0x86, 0x69, 0xd4, 0x0f, 0xcb, 0xcf, 0xd1, 0x4c, 0x03, 0xad, 0x79, 0x4e, 0x83, 0x02, - 0xb8, 0x95, 0x02, 0x37, 0x12, 0xe0, 0xed, 0x92, 0x07, 0x9a, 0x18, 0xce, 0x60, 0xde, 0xfd, 0xe2, - 0xe0, 0x50, 0x47, 0xcf, 0x0e, 0x75, 0xf4, 0xe7, 0xa1, 0x8e, 0xbe, 0x3b, 0xd2, 0x2b, 0xcf, 0x8e, - 0xf4, 0xca, 0x1f, 0x47, 0x7a, 0xe5, 0xf3, 0x1d, 0x8f, 0xa9, 0x5e, 0xbf, 0x6b, 0x3a, 0x22, 0x18, - 0xdf, 0xe3, 0xce, 0x57, 0x82, 0xc3, 0xc4, 0xa6, 0x8f, 0x67, 0x6c, 0xa8, 0x06, 0x21, 0xc8, 0xee, - 0x2b, 0xe9, 0x9f, 0xbb, 0x7b, 0xff, 0x07, 0x00, 0x00, 0xff, 0xff, 0x02, 0xcc, 0x63, 0xf0, 0xd2, - 0x0a, 0x00, 0x00, + // 956 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x97, 0x4f, 0x6f, 0xdc, 0x44, + 0x18, 0xc6, 0x77, 0xfa, 0x87, 0x36, 0x93, 0x42, 0x82, 0x13, 0xa9, 0x89, 0x69, 0x77, 0x23, 0x9f, + 0x2a, 0xa0, 0x76, 0x37, 0xa5, 0x29, 0x24, 0x6d, 0x20, 0xbb, 0x11, 0xab, 0xa0, 0xe6, 0xe2, 0x08, + 0x0e, 0x70, 0x58, 0x4d, 0xd6, 0x2f, 0xde, 0x51, 0xbd, 0x33, 0xae, 0x67, 0xd6, 0x6d, 0x38, 0x72, + 0x42, 0x82, 0x03, 0x12, 0x5f, 0x20, 0x67, 0xce, 0x15, 0x57, 0x0e, 0x70, 0x88, 0xc4, 0x81, 0x0a, + 0x2e, 0x9c, 0x22, 0x94, 0x80, 0xc4, 0x09, 0x89, 0x7c, 0x02, 0xe4, 0xb1, 0xd7, 0xf5, 0x7a, 0x8d, + 0xe2, 0xdd, 0x46, 0xe2, 0xb6, 0x9e, 0xf1, 0xf3, 0xf8, 0xf9, 0xcd, 0xfb, 0xce, 0x2b, 0x2d, 0xb6, + 0x1e, 0xf5, 0x69, 0xe7, 0xa1, 0xa0, 0x5e, 0x08, 0x81, 0x45, 0x99, 0x84, 0xa0, 0xd3, 0x25, 0x94, + 0x09, 0x49, 0x1e, 0x52, 0xe6, 0x5a, 0x61, 0xdd, 0xea, 0x81, 0x10, 0xc4, 0x05, 0x61, 0xfa, 0x01, + 0x97, 0x5c, 0x5b, 0xca, 0x08, 0xcc, 0x11, 0x81, 0x19, 0xd6, 0xf5, 0x6a, 0x87, 0x8b, 0x1e, 0x17, + 0xd6, 0x2e, 0x11, 0x60, 0x85, 0xf5, 0x5d, 0x90, 0xa4, 0x6e, 0x75, 0x38, 0x65, 0xb1, 0x83, 0xbe, + 0x18, 0xef, 0xb7, 0xd5, 0x93, 0x15, 0x3f, 0x24, 0x5b, 0xf3, 0x2e, 0x77, 0x79, 0xbc, 0x1e, 0xfd, + 0x4a, 0x56, 0xaf, 0xb9, 0x9c, 0xbb, 0x1e, 0x58, 0xc4, 0xa7, 0x16, 0x61, 0x8c, 0x4b, 0x22, 0x29, + 0x67, 0x03, 0xcd, 0xad, 0x53, 0x09, 0xfc, 0x80, 0xfb, 0x5c, 0x10, 0x2f, 0x51, 0x18, 0x7f, 0x23, + 0x3c, 0xbf, 0x2d, 0x5c, 0x1b, 0x1e, 0xf5, 0x41, 0x48, 0x1b, 0x1c, 0xe8, 0xf9, 0x91, 0xa3, 0xb6, + 0x89, 0x2f, 0x86, 0xc4, 0xeb, 0xc3, 0x02, 0x5a, 0x42, 0x37, 0xa6, 0x97, 0x17, 0xcd, 0x24, 0x5c, + 0x44, 0x62, 0x26, 0x24, 0x66, 0x93, 0x53, 0xd6, 0x98, 0x3b, 0x38, 0xac, 0x55, 0x4e, 0x0e, 0x6b, + 0xd3, 0x7b, 0xa4, 0xe7, 0xad, 0x1a, 0x11, 0x9d, 0x61, 0xc7, 0x62, 0x6d, 0x0b, 0xcf, 0x39, 0x20, + 0x24, 0x65, 0x2a, 0x66, 0x9b, 0x38, 0x4e, 0x00, 0x42, 0x2c, 0x9c, 0x5b, 0x42, 0x37, 0xa6, 0x1a, + 0x0b, 0xbf, 0x3c, 0xbd, 0x39, 0x9f, 0xd8, 0x6e, 0xc4, 0x3b, 0x3b, 0x32, 0xa0, 0xcc, 0xb5, 0xb5, + 0x8c, 0x28, 0xd9, 0xd1, 0xd6, 0xf0, 0x95, 0x4f, 0x03, 0xde, 0x4b, 0x3d, 0xce, 0x9f, 0xe2, 0x31, + 0x1d, 0xbd, 0x9d, 0x2c, 0xad, 0x5e, 0xfe, 0x62, 0xbf, 0x56, 0xf9, 0x6b, 0xbf, 0x56, 0x31, 0xaa, + 0xf8, 0x5a, 0x11, 0xaf, 0x0d, 0xc2, 0xe7, 0x4c, 0x80, 0xf1, 0x25, 0xc2, 0x73, 0xdb, 0xc2, 0x6d, + 0x12, 0xd6, 0x01, 0x2f, 0x73, 0x1e, 0x8b, 0xf8, 0xb2, 0x3a, 0xcb, 0x36, 0x75, 0xd4, 0x91, 0x4c, + 0xd9, 0x97, 0xd4, 0xf3, 0x96, 0xa3, 0x69, 0xf8, 0x42, 0x97, 0x88, 0x6e, 0x4c, 0x65, 0xab, 0xdf, + 0x67, 0x95, 0x96, 0xe2, 0xd7, 0x0a, 0xc2, 0x0c, 0xc2, 0x6a, 0x1f, 0xe0, 0xcb, 0x01, 0xc8, 0x7e, + 0xc0, 0xc0, 0x99, 0xb0, 0x4e, 0xa9, 0xde, 0xf8, 0x36, 0x06, 0xff, 0xd0, 0x77, 0x88, 0x84, 0xc9, + 0xc1, 0xaf, 0x63, 0xcc, 0xe0, 0x71, 0x5b, 0x48, 0x22, 0xfb, 0x31, 0xf6, 0x45, 0x7b, 0x8a, 0xc1, + 0xe3, 0x1d, 0xb5, 0x30, 0x72, 0x2e, 0x17, 0x26, 0x3b, 0x97, 0xeb, 0xea, 0x5c, 0xf2, 0x59, 0xd3, + 0x22, 0x7e, 0x95, 0xe9, 0xea, 0x3e, 0xfc, 0xef, 0x55, 0xcc, 0xf4, 0x5c, 0xbf, 0x28, 0xee, 0x77, + 0x08, 0xcf, 0x6c, 0x0b, 0x77, 0x87, 0xba, 0x8c, 0x78, 0x5b, 0x4c, 0x02, 0x93, 0x9a, 0x99, 0x4f, + 0xda, 0x98, 0x3b, 0x39, 0xac, 0xcd, 0x24, 0xb5, 0x4b, 0x76, 0x8c, 0xe7, 0xf1, 0xdf, 0xc4, 0x97, + 0xa8, 0x52, 0x0e, 0x6e, 0x97, 0x76, 0x72, 0x58, 0x7b, 0x25, 0x7e, 0x3d, 0xd9, 0x30, 0xec, 0xc1, + 0x2b, 0x67, 0x05, 0xb6, 0x88, 0xaf, 0xe6, 0x72, 0x0f, 0x98, 0x96, 0xf7, 0x67, 0xf1, 0xf9, 0x6d, + 0xe1, 0x6a, 0x3f, 0x20, 0xfc, 0xea, 0xe8, 0x74, 0x59, 0x31, 0x4f, 0x1b, 0x9d, 0x66, 0xd1, 0x2d, + 0xd5, 0xd7, 0x27, 0xd3, 0xa5, 0x27, 0xbd, 0xf2, 0xf9, 0xaf, 0x7f, 0x7c, 0x73, 0xee, 0x96, 0xf1, + 0xc6, 0xd0, 0xac, 0x97, 0x4f, 0xa2, 0xd1, 0x38, 0x3a, 0x2f, 0x03, 0x70, 0x00, 0x7a, 0xab, 0xe8, + 0x75, 0xed, 0x29, 0xc2, 0x57, 0x86, 0xca, 0x53, 0x2f, 0x15, 0x24, 0x2b, 0xd1, 0xdf, 0x19, 0x5b, + 0x32, 0x61, 0xec, 0xb8, 0xc8, 0x51, 0xec, 0x9f, 0x10, 0x9e, 0x1d, 0x99, 0x64, 0x77, 0x4a, 0xe5, + 0xc8, 0xcb, 0xf4, 0xfb, 0x13, 0xc9, 0x52, 0x84, 0x0d, 0x85, 0xb0, 0x66, 0xac, 0x94, 0x42, 0xe8, + 0x28, 0x9b, 0x76, 0x90, 0xfa, 0x44, 0x34, 0x3f, 0x0f, 0x5a, 0x69, 0xe8, 0x4a, 0x8f, 0xd1, 0x4a, + 0x59, 0xdd, 0x38, 0xad, 0x54, 0x78, 0x69, 0x1b, 0x0a, 0xe8, 0x9e, 0x71, 0xb7, 0x64, 0x2b, 0x29, + 0x9f, 0x1c, 0x51, 0x54, 0x9f, 0x91, 0x81, 0x5b, 0xae, 0x3e, 0x79, 0x59, 0xc9, 0xfa, 0xfc, 0xe7, + 0xc8, 0x1c, 0xaf, 0x3e, 0x7d, 0x65, 0x93, 0xa3, 0xf9, 0x11, 0xe1, 0x99, 0x16, 0x0f, 0x9b, 0x1e, + 0x17, 0xd0, 0xec, 0x12, 0xc6, 0xc0, 0xd3, 0xde, 0x2a, 0x95, 0x2a, 0xa7, 0xd2, 0xef, 0x4d, 0xa2, + 0x4a, 0x51, 0xee, 0x2b, 0x94, 0xbb, 0xc6, 0x72, 0xb9, 0x56, 0x8b, 0x2c, 0xda, 0x9d, 0xd8, 0x23, + 0xc2, 0x38, 0x40, 0x78, 0xb6, 0xc5, 0x43, 0x1b, 0xb8, 0x0f, 0x6c, 0xc0, 0x71, 0xa7, 0x6c, 0xa2, + 0x21, 0x59, 0xc9, 0xa2, 0xe4, 0x65, 0x29, 0xc9, 0xba, 0x22, 0x79, 0xdb, 0xb8, 0x5d, 0xb2, 0xc7, + 0x22, 0x8f, 0x2c, 0xca, 0xf7, 0x08, 0xbf, 0xdc, 0xe2, 0xe1, 0x0e, 0xc8, 0x07, 0xa2, 0xd7, 0x24, + 0xbe, 0xd0, 0x96, 0xcb, 0x06, 0x7a, 0xae, 0xd1, 0x57, 0xc7, 0xd7, 0x9c, 0x19, 0xc1, 0x9f, 0x08, + 0x5f, 0x6d, 0xf1, 0x70, 0xc3, 0x71, 0x3e, 0x22, 0x1e, 0x75, 0x88, 0xe4, 0xc1, 0x26, 0xb0, 0xbd, + 0x07, 0x54, 0x48, 0xad, 0x74, 0x97, 0x14, 0xa9, 0xf5, 0xcd, 0x17, 0x51, 0xa7, 0x7c, 0xef, 0x2b, + 0xbe, 0xf7, 0x8c, 0xb5, 0x52, 0x7c, 0xc4, 0x71, 0xda, 0xe1, 0xc0, 0xab, 0xed, 0x00, 0xdb, 0xf3, + 0xa8, 0x50, 0x93, 0xfa, 0x1f, 0x84, 0x75, 0xd5, 0x06, 0x3d, 0x1e, 0xc2, 0x28, 0xea, 0xbb, 0xe5, + 0xfb, 0xa8, 0xd0, 0x40, 0x6f, 0xbd, 0xa0, 0x41, 0x0a, 0xbc, 0xa5, 0x80, 0x9b, 0xc6, 0x7a, 0xc9, + 0x82, 0x46, 0x6e, 0xc5, 0xcc, 0x8d, 0x4f, 0x0e, 0x8e, 0xaa, 0xe8, 0xd9, 0x51, 0x15, 0xfd, 0x7e, + 0x54, 0x45, 0x5f, 0x1f, 0x57, 0x2b, 0xcf, 0x8e, 0xab, 0x95, 0xdf, 0x8e, 0xab, 0x95, 0x8f, 0x37, + 0x5c, 0x2a, 0xbb, 0xfd, 0x5d, 0xb3, 0xc3, 0x7b, 0xd9, 0xcf, 0xdc, 0xfc, 0x8c, 0x33, 0x18, 0xfa, + 0xee, 0x93, 0x82, 0x6f, 0xca, 0x3d, 0x1f, 0xc4, 0xee, 0x4b, 0xea, 0xff, 0xcd, 0xed, 0x7f, 0x03, + 0x00, 0x00, 0xff, 0xff, 0xf2, 0xf5, 0xdb, 0x0a, 0xd5, 0x0d, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -361,9 +526,13 @@ type MsgClient interface { // SignalIntent defines a method for signalling voting intent for one or more // validators. SignalIntent(ctx context.Context, in *MsgSignalIntent, opts ...grpc.CallOption) (*MsgSignalIntentResponse, error) - // CancelRedemption defines a method for cancelling a redemption request in - // the queued state. - CancelRedemption(ctx context.Context, in *MsgCancelQueuedRedemption, opts ...grpc.CallOption) (*MsgCancelQueuedRedemptionResponse, error) + // CancelRedemption defines a method for cancelling a redemption request and + // returning the escrowed assets. + CancelRedemption(ctx context.Context, in *MsgCancelRedemption, opts ...grpc.CallOption) (*MsgCancelRedemptionResponse, error) + // RequeueRedemption defines a method for requeuing a failed redemption. + RequeueRedemption(ctx context.Context, in *MsgRequeueRedemption, opts ...grpc.CallOption) (*MsgRequeueRedemptionResponse, error) + // UpdateRedemption defines a method for updating a redemption. + UpdateRedemption(ctx context.Context, in *MsgUpdateRedemption, opts ...grpc.CallOption) (*MsgUpdateRedemptionResponse, error) // SignalIntent defines a method for signalling voting intent for one or more // validators. GovCloseChannel(ctx context.Context, in *MsgGovCloseChannel, opts ...grpc.CallOption) (*MsgGovCloseChannelResponse, error) @@ -399,8 +568,8 @@ func (c *msgClient) SignalIntent(ctx context.Context, in *MsgSignalIntent, opts return out, nil } -func (c *msgClient) CancelRedemption(ctx context.Context, in *MsgCancelQueuedRedemption, opts ...grpc.CallOption) (*MsgCancelQueuedRedemptionResponse, error) { - out := new(MsgCancelQueuedRedemptionResponse) +func (c *msgClient) CancelRedemption(ctx context.Context, in *MsgCancelRedemption, opts ...grpc.CallOption) (*MsgCancelRedemptionResponse, error) { + out := new(MsgCancelRedemptionResponse) err := c.cc.Invoke(ctx, "/quicksilver.interchainstaking.v1.Msg/CancelRedemption", in, out, opts...) if err != nil { return nil, err @@ -408,6 +577,24 @@ func (c *msgClient) CancelRedemption(ctx context.Context, in *MsgCancelQueuedRed return out, nil } +func (c *msgClient) RequeueRedemption(ctx context.Context, in *MsgRequeueRedemption, opts ...grpc.CallOption) (*MsgRequeueRedemptionResponse, error) { + out := new(MsgRequeueRedemptionResponse) + err := c.cc.Invoke(ctx, "/quicksilver.interchainstaking.v1.Msg/RequeueRedemption", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgClient) UpdateRedemption(ctx context.Context, in *MsgUpdateRedemption, opts ...grpc.CallOption) (*MsgUpdateRedemptionResponse, error) { + out := new(MsgUpdateRedemptionResponse) + err := c.cc.Invoke(ctx, "/quicksilver.interchainstaking.v1.Msg/UpdateRedemption", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *msgClient) GovCloseChannel(ctx context.Context, in *MsgGovCloseChannel, opts ...grpc.CallOption) (*MsgGovCloseChannelResponse, error) { out := new(MsgGovCloseChannelResponse) err := c.cc.Invoke(ctx, "/quicksilver.interchainstaking.v1.Msg/GovCloseChannel", in, out, opts...) @@ -461,9 +648,13 @@ type MsgServer interface { // SignalIntent defines a method for signalling voting intent for one or more // validators. SignalIntent(context.Context, *MsgSignalIntent) (*MsgSignalIntentResponse, error) - // CancelRedemption defines a method for cancelling a redemption request in - // the queued state. - CancelRedemption(context.Context, *MsgCancelQueuedRedemption) (*MsgCancelQueuedRedemptionResponse, error) + // CancelRedemption defines a method for cancelling a redemption request and + // returning the escrowed assets. + CancelRedemption(context.Context, *MsgCancelRedemption) (*MsgCancelRedemptionResponse, error) + // RequeueRedemption defines a method for requeuing a failed redemption. + RequeueRedemption(context.Context, *MsgRequeueRedemption) (*MsgRequeueRedemptionResponse, error) + // UpdateRedemption defines a method for updating a redemption. + UpdateRedemption(context.Context, *MsgUpdateRedemption) (*MsgUpdateRedemptionResponse, error) // SignalIntent defines a method for signalling voting intent for one or more // validators. GovCloseChannel(context.Context, *MsgGovCloseChannel) (*MsgGovCloseChannelResponse, error) @@ -483,9 +674,15 @@ func (*UnimplementedMsgServer) RequestRedemption(ctx context.Context, req *MsgRe func (*UnimplementedMsgServer) SignalIntent(ctx context.Context, req *MsgSignalIntent) (*MsgSignalIntentResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method SignalIntent not implemented") } -func (*UnimplementedMsgServer) CancelRedemption(ctx context.Context, req *MsgCancelQueuedRedemption) (*MsgCancelQueuedRedemptionResponse, error) { +func (*UnimplementedMsgServer) CancelRedemption(ctx context.Context, req *MsgCancelRedemption) (*MsgCancelRedemptionResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method CancelRedemption not implemented") } +func (*UnimplementedMsgServer) RequeueRedemption(ctx context.Context, req *MsgRequeueRedemption) (*MsgRequeueRedemptionResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method RequeueRedemption not implemented") +} +func (*UnimplementedMsgServer) UpdateRedemption(ctx context.Context, req *MsgUpdateRedemption) (*MsgUpdateRedemptionResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method UpdateRedemption not implemented") +} func (*UnimplementedMsgServer) GovCloseChannel(ctx context.Context, req *MsgGovCloseChannel) (*MsgGovCloseChannelResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GovCloseChannel not implemented") } @@ -543,7 +740,7 @@ func _Msg_SignalIntent_Handler(srv interface{}, ctx context.Context, dec func(in } func _Msg_CancelRedemption_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgCancelQueuedRedemption) + in := new(MsgCancelRedemption) if err := dec(in); err != nil { return nil, err } @@ -555,7 +752,43 @@ func _Msg_CancelRedemption_Handler(srv interface{}, ctx context.Context, dec fun FullMethod: "/quicksilver.interchainstaking.v1.Msg/CancelRedemption", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).CancelRedemption(ctx, req.(*MsgCancelQueuedRedemption)) + return srv.(MsgServer).CancelRedemption(ctx, req.(*MsgCancelRedemption)) + } + return interceptor(ctx, in, info, handler) +} + +func _Msg_RequeueRedemption_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgRequeueRedemption) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).RequeueRedemption(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/quicksilver.interchainstaking.v1.Msg/RequeueRedemption", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).RequeueRedemption(ctx, req.(*MsgRequeueRedemption)) + } + return interceptor(ctx, in, info, handler) +} + +func _Msg_UpdateRedemption_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgUpdateRedemption) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).UpdateRedemption(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/quicksilver.interchainstaking.v1.Msg/UpdateRedemption", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).UpdateRedemption(ctx, req.(*MsgUpdateRedemption)) } return interceptor(ctx, in, info, handler) } @@ -666,6 +899,14 @@ var _Msg_serviceDesc = grpc.ServiceDesc{ MethodName: "CancelRedemption", Handler: _Msg_CancelRedemption_Handler, }, + { + MethodName: "RequeueRedemption", + Handler: _Msg_RequeueRedemption_Handler, + }, + { + MethodName: "UpdateRedemption", + Handler: _Msg_UpdateRedemption_Handler, + }, { MethodName: "GovCloseChannel", Handler: _Msg_GovCloseChannel_Handler, @@ -761,7 +1002,7 @@ func (m *MsgRequestRedemptionResponse) MarshalToSizedBuffer(dAtA []byte) (int, e return len(dAtA) - i, nil } -func (m *MsgCancelQueuedRedemption) Marshal() (dAtA []byte, err error) { +func (m *MsgCancelRedemption) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -771,12 +1012,12 @@ func (m *MsgCancelQueuedRedemption) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgCancelQueuedRedemption) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgCancelRedemption) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgCancelQueuedRedemption) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgCancelRedemption) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -805,7 +1046,7 @@ func (m *MsgCancelQueuedRedemption) MarshalToSizedBuffer(dAtA []byte) (int, erro return len(dAtA) - i, nil } -func (m *MsgCancelQueuedRedemptionResponse) Marshal() (dAtA []byte, err error) { +func (m *MsgCancelRedemptionResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -815,12 +1056,12 @@ func (m *MsgCancelQueuedRedemptionResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgCancelQueuedRedemptionResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgCancelRedemptionResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgCancelQueuedRedemptionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgCancelRedemptionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -838,7 +1079,7 @@ func (m *MsgCancelQueuedRedemptionResponse) MarshalToSizedBuffer(dAtA []byte) (i return len(dAtA) - i, nil } -func (m *MsgSignalIntent) Marshal() (dAtA []byte, err error) { +func (m *MsgUpdateRedemption) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -848,12 +1089,12 @@ func (m *MsgSignalIntent) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgSignalIntent) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgUpdateRedemption) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgSignalIntent) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgUpdateRedemption) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -863,12 +1104,17 @@ func (m *MsgSignalIntent) MarshalToSizedBuffer(dAtA []byte) (int, error) { copy(dAtA[i:], m.FromAddress) i = encodeVarintMessages(dAtA, i, uint64(len(m.FromAddress))) i-- - dAtA[i] = 0x1a + dAtA[i] = 0x22 } - if len(m.Intents) > 0 { - i -= len(m.Intents) - copy(dAtA[i:], m.Intents) - i = encodeVarintMessages(dAtA, i, uint64(len(m.Intents))) + if m.NewStatus != 0 { + i = encodeVarintMessages(dAtA, i, uint64(m.NewStatus)) + i-- + dAtA[i] = 0x18 + } + if len(m.Hash) > 0 { + i -= len(m.Hash) + copy(dAtA[i:], m.Hash) + i = encodeVarintMessages(dAtA, i, uint64(len(m.Hash))) i-- dAtA[i] = 0x12 } @@ -882,7 +1128,7 @@ func (m *MsgSignalIntent) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *MsgSignalIntentResponse) Marshal() (dAtA []byte, err error) { +func (m *MsgUpdateRedemptionResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -892,12 +1138,12 @@ func (m *MsgSignalIntentResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgSignalIntentResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgUpdateRedemptionResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgSignalIntentResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgUpdateRedemptionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -905,85 +1151,282 @@ func (m *MsgSignalIntentResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) return len(dAtA) - i, nil } -func encodeVarintMessages(dAtA []byte, offset int, v uint64) int { - offset -= sovMessages(v) - base := offset - for v >= 1<<7 { - dAtA[offset] = uint8(v&0x7f | 0x80) - v >>= 7 - offset++ - } - dAtA[offset] = uint8(v) - return base -} -func (m *MsgRequestRedemption) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = m.Value.Size() - n += 1 + l + sovMessages(uint64(l)) - l = len(m.DestinationAddress) - if l > 0 { - n += 1 + l + sovMessages(uint64(l)) - } - l = len(m.FromAddress) - if l > 0 { - n += 1 + l + sovMessages(uint64(l)) +func (m *MsgRequeueRedemption) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - return n + return dAtA[:n], nil } -func (m *MsgRequestRedemptionResponse) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - return n +func (m *MsgRequeueRedemption) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgCancelQueuedRedemption) Size() (n int) { - if m == nil { - return 0 - } +func (m *MsgRequeueRedemption) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - l = len(m.ChainId) - if l > 0 { - n += 1 + l + sovMessages(uint64(l)) + if len(m.FromAddress) > 0 { + i -= len(m.FromAddress) + copy(dAtA[i:], m.FromAddress) + i = encodeVarintMessages(dAtA, i, uint64(len(m.FromAddress))) + i-- + dAtA[i] = 0x1a } - l = len(m.Hash) - if l > 0 { - n += 1 + l + sovMessages(uint64(l)) + if len(m.Hash) > 0 { + i -= len(m.Hash) + copy(dAtA[i:], m.Hash) + i = encodeVarintMessages(dAtA, i, uint64(len(m.Hash))) + i-- + dAtA[i] = 0x12 } - l = len(m.FromAddress) - if l > 0 { - n += 1 + l + sovMessages(uint64(l)) + if len(m.ChainId) > 0 { + i -= len(m.ChainId) + copy(dAtA[i:], m.ChainId) + i = encodeVarintMessages(dAtA, i, uint64(len(m.ChainId))) + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *MsgCancelQueuedRedemptionResponse) Size() (n int) { - if m == nil { - return 0 +func (m *MsgRequeueRedemptionResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - var l int - _ = l - l = m.Returned.Size() - n += 1 + l + sovMessages(uint64(l)) - return n + return dAtA[:n], nil } -func (m *MsgSignalIntent) Size() (n int) { - if m == nil { - return 0 - } +func (m *MsgRequeueRedemptionResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgRequeueRedemptionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - l = len(m.ChainId) - if l > 0 { + return len(dAtA) - i, nil +} + +func (m *MsgSignalIntent) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgSignalIntent) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgSignalIntent) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.FromAddress) > 0 { + i -= len(m.FromAddress) + copy(dAtA[i:], m.FromAddress) + i = encodeVarintMessages(dAtA, i, uint64(len(m.FromAddress))) + i-- + dAtA[i] = 0x1a + } + if len(m.Intents) > 0 { + i -= len(m.Intents) + copy(dAtA[i:], m.Intents) + i = encodeVarintMessages(dAtA, i, uint64(len(m.Intents))) + i-- + dAtA[i] = 0x12 + } + if len(m.ChainId) > 0 { + i -= len(m.ChainId) + copy(dAtA[i:], m.ChainId) + i = encodeVarintMessages(dAtA, i, uint64(len(m.ChainId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgSignalIntentResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgSignalIntentResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgSignalIntentResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func encodeVarintMessages(dAtA []byte, offset int, v uint64) int { + offset -= sovMessages(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *MsgRequestRedemption) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Value.Size() + n += 1 + l + sovMessages(uint64(l)) + l = len(m.DestinationAddress) + if l > 0 { + n += 1 + l + sovMessages(uint64(l)) + } + l = len(m.FromAddress) + if l > 0 { + n += 1 + l + sovMessages(uint64(l)) + } + return n +} + +func (m *MsgRequestRedemptionResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgCancelRedemption) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ChainId) + if l > 0 { + n += 1 + l + sovMessages(uint64(l)) + } + l = len(m.Hash) + if l > 0 { + n += 1 + l + sovMessages(uint64(l)) + } + l = len(m.FromAddress) + if l > 0 { + n += 1 + l + sovMessages(uint64(l)) + } + return n +} + +func (m *MsgCancelRedemptionResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Returned.Size() + n += 1 + l + sovMessages(uint64(l)) + return n +} + +func (m *MsgUpdateRedemption) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ChainId) + if l > 0 { + n += 1 + l + sovMessages(uint64(l)) + } + l = len(m.Hash) + if l > 0 { + n += 1 + l + sovMessages(uint64(l)) + } + if m.NewStatus != 0 { + n += 1 + sovMessages(uint64(m.NewStatus)) + } + l = len(m.FromAddress) + if l > 0 { + n += 1 + l + sovMessages(uint64(l)) + } + return n +} + +func (m *MsgUpdateRedemptionResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgRequeueRedemption) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ChainId) + if l > 0 { + n += 1 + l + sovMessages(uint64(l)) + } + l = len(m.Hash) + if l > 0 { + n += 1 + l + sovMessages(uint64(l)) + } + l = len(m.FromAddress) + if l > 0 { + n += 1 + l + sovMessages(uint64(l)) + } + return n +} + +func (m *MsgRequeueRedemptionResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgSignalIntent) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ChainId) + if l > 0 { n += 1 + l + sovMessages(uint64(l)) } l = len(m.Intents) @@ -1209,7 +1652,7 @@ func (m *MsgRequestRedemptionResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgCancelQueuedRedemption) Unmarshal(dAtA []byte) error { +func (m *MsgCancelRedemption) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -1232,10 +1675,10 @@ func (m *MsgCancelQueuedRedemption) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgCancelQueuedRedemption: wiretype end group for non-group") + return fmt.Errorf("proto: MsgCancelRedemption: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgCancelQueuedRedemption: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgCancelRedemption: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -1355,7 +1798,7 @@ func (m *MsgCancelQueuedRedemption) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgCancelQueuedRedemptionResponse) Unmarshal(dAtA []byte) error { +func (m *MsgCancelRedemptionResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -1378,10 +1821,10 @@ func (m *MsgCancelQueuedRedemptionResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgCancelQueuedRedemptionResponse: wiretype end group for non-group") + return fmt.Errorf("proto: MsgCancelRedemptionResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgCancelQueuedRedemptionResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgCancelRedemptionResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -1438,6 +1881,417 @@ func (m *MsgCancelQueuedRedemptionResponse) Unmarshal(dAtA []byte) error { } return nil } +func (m *MsgUpdateRedemption) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMessages + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgUpdateRedemption: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgUpdateRedemption: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMessages + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthMessages + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthMessages + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ChainId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMessages + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthMessages + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthMessages + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Hash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field NewStatus", wireType) + } + m.NewStatus = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMessages + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.NewStatus |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FromAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMessages + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthMessages + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthMessages + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FromAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipMessages(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthMessages + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgUpdateRedemptionResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMessages + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgUpdateRedemptionResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgUpdateRedemptionResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipMessages(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthMessages + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgRequeueRedemption) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMessages + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgRequeueRedemption: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgRequeueRedemption: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMessages + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthMessages + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthMessages + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ChainId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMessages + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthMessages + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthMessages + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Hash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FromAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMessages + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthMessages + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthMessages + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FromAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipMessages(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthMessages + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgRequeueRedemptionResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMessages + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgRequeueRedemptionResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgRequeueRedemptionResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipMessages(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthMessages + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func (m *MsgSignalIntent) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 diff --git a/x/interchainstaking/types/messages.pb.gw.go b/x/interchainstaking/types/messages.pb.gw.go index 48b7fa40e..6123dd2b5 100644 --- a/x/interchainstaking/types/messages.pb.gw.go +++ b/x/interchainstaking/types/messages.pb.gw.go @@ -102,7 +102,7 @@ func local_request_Msg_SignalIntent_0(ctx context.Context, marshaler runtime.Mar } func request_Msg_CancelRedemption_0(ctx context.Context, marshaler runtime.Marshaler, client MsgClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq MsgCancelQueuedRedemption + var protoReq MsgCancelRedemption var metadata runtime.ServerMetadata newReader, berr := utilities.IOReaderFactory(req.Body) @@ -119,7 +119,7 @@ func request_Msg_CancelRedemption_0(ctx context.Context, marshaler runtime.Marsh } func local_request_Msg_CancelRedemption_0(ctx context.Context, marshaler runtime.Marshaler, server MsgServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq MsgCancelQueuedRedemption + var protoReq MsgCancelRedemption var metadata runtime.ServerMetadata newReader, berr := utilities.IOReaderFactory(req.Body) @@ -135,6 +135,74 @@ func local_request_Msg_CancelRedemption_0(ctx context.Context, marshaler runtime } +func request_Msg_RequeueRedemption_0(ctx context.Context, marshaler runtime.Marshaler, client MsgClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq MsgRequeueRedemption + var metadata runtime.ServerMetadata + + newReader, berr := utilities.IOReaderFactory(req.Body) + if berr != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) + } + if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.RequeueRedemption(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Msg_RequeueRedemption_0(ctx context.Context, marshaler runtime.Marshaler, server MsgServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq MsgRequeueRedemption + var metadata runtime.ServerMetadata + + newReader, berr := utilities.IOReaderFactory(req.Body) + if berr != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) + } + if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.RequeueRedemption(ctx, &protoReq) + return msg, metadata, err + +} + +func request_Msg_UpdateRedemption_0(ctx context.Context, marshaler runtime.Marshaler, client MsgClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq MsgUpdateRedemption + var metadata runtime.ServerMetadata + + newReader, berr := utilities.IOReaderFactory(req.Body) + if berr != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) + } + if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.UpdateRedemption(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Msg_UpdateRedemption_0(ctx context.Context, marshaler runtime.Marshaler, server MsgServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq MsgUpdateRedemption + var metadata runtime.ServerMetadata + + newReader, berr := utilities.IOReaderFactory(req.Body) + if berr != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) + } + if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.UpdateRedemption(ctx, &protoReq) + return msg, metadata, err + +} + func request_Msg_GovCloseChannel_0(ctx context.Context, marshaler runtime.Marshaler, client MsgClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var protoReq MsgGovCloseChannel var metadata runtime.ServerMetadata @@ -380,6 +448,52 @@ func RegisterMsgHandlerServer(ctx context.Context, mux *runtime.ServeMux, server }) + mux.Handle("POST", pattern_Msg_RequeueRedemption_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_Msg_RequeueRedemption_0(rctx, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Msg_RequeueRedemption_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_Msg_UpdateRedemption_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_Msg_UpdateRedemption_0(rctx, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Msg_UpdateRedemption_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + mux.Handle("POST", pattern_Msg_GovCloseChannel_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() @@ -596,6 +710,46 @@ func RegisterMsgHandlerClient(ctx context.Context, mux *runtime.ServeMux, client }) + mux.Handle("POST", pattern_Msg_RequeueRedemption_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_Msg_RequeueRedemption_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Msg_RequeueRedemption_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("POST", pattern_Msg_UpdateRedemption_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_Msg_UpdateRedemption_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Msg_UpdateRedemption_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + mux.Handle("POST", pattern_Msg_GovCloseChannel_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() @@ -706,6 +860,10 @@ var ( pattern_Msg_CancelRedemption_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"quicksilver", "tx", "v1", "interchainstaking", "cancel_redemption"}, "", runtime.AssumeColonVerbOpt(true))) + pattern_Msg_RequeueRedemption_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"quicksilver", "tx", "v1", "interchainstaking", "requeue_redemption"}, "", runtime.AssumeColonVerbOpt(true))) + + pattern_Msg_UpdateRedemption_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"quicksilver", "tx", "v1", "interchainstaking", "update_redemption"}, "", runtime.AssumeColonVerbOpt(true))) + pattern_Msg_GovCloseChannel_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"quicksilver", "tx", "v1", "interchainstaking", "close_channel"}, "", runtime.AssumeColonVerbOpt(true))) pattern_Msg_GovReopenChannel_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"quicksilver", "tx", "v1", "interchainstaking", "reopen_channel"}, "", runtime.AssumeColonVerbOpt(true))) @@ -724,6 +882,10 @@ var ( forward_Msg_CancelRedemption_0 = runtime.ForwardResponseMessage + forward_Msg_RequeueRedemption_0 = runtime.ForwardResponseMessage + + forward_Msg_UpdateRedemption_0 = runtime.ForwardResponseMessage + forward_Msg_GovCloseChannel_0 = runtime.ForwardResponseMessage forward_Msg_GovReopenChannel_0 = runtime.ForwardResponseMessage diff --git a/x/interchainstaking/types/msgs.go b/x/interchainstaking/types/msgs.go index 80b30c01f..69b905e45 100644 --- a/x/interchainstaking/types/msgs.go +++ b/x/interchainstaking/types/msgs.go @@ -18,20 +18,24 @@ import ( // interchainstaking message types. const ( - TypeMsgRequestRedemption = "requestredemption" - TypeMsgCancelQueuedRedemption = "cancelqueuedredemption" - TypeMsgSignalIntent = "signalintent" + TypeMsgRequestRedemption = "requestredemption" + TypeMsgCancelRedemption = "cancelredemption" + TypeMsgRequeueRedemption = "requeueredemption" + TypeMsgUpdateRedemption = "updateredemption" + TypeMsgSignalIntent = "signalintent" ) var ( _ sdk.Msg = &MsgRequestRedemption{} - _ sdk.Msg = &MsgCancelQueuedRedemption{} + _ sdk.Msg = &MsgCancelRedemption{} + _ sdk.Msg = &MsgRequeueRedemption{} _ sdk.Msg = &MsgSignalIntent{} _ sdk.Msg = &MsgGovCloseChannel{} _ sdk.Msg = &MsgGovReopenChannel{} _ sdk.Msg = &MsgGovSetLsmCaps{} _ legacytx.LegacyMsg = &MsgRequestRedemption{} - _ legacytx.LegacyMsg = &MsgCancelQueuedRedemption{} + _ legacytx.LegacyMsg = &MsgCancelRedemption{} + _ legacytx.LegacyMsg = &MsgRequeueRedemption{} _ legacytx.LegacyMsg = &MsgSignalIntent{} _ sdk.Msg = &MsgGovAddValidatorDenyList{} _ sdk.Msg = &MsgGovRemoveValidatorDenyList{} @@ -95,18 +99,18 @@ func (msg MsgRequestRedemption) GetSigners() []sdk.AccAddress { var hexpr = regexp.MustCompile("^[A-Fa-f0-9]{64}$") // NewMsgCancelQueuedRedemption - construct a msg to cancel a requested redemption. -func NewMsgCancelQueuedRedemption(chainID string, hash string, fromAddress sdk.Address) *MsgCancelQueuedRedemption { - return &MsgCancelQueuedRedemption{ChainId: chainID, Hash: hash, FromAddress: fromAddress.String()} +func NewMsgCancelRedemption(chainID string, hash string, fromAddress sdk.Address) *MsgCancelRedemption { + return &MsgCancelRedemption{ChainId: chainID, Hash: hash, FromAddress: fromAddress.String()} } // Route Implements Msg. -func (MsgCancelQueuedRedemption) Route() string { return RouterKey } +func (MsgCancelRedemption) Route() string { return RouterKey } // Type Implements Msg. -func (MsgCancelQueuedRedemption) Type() string { return TypeMsgCancelQueuedRedemption } +func (MsgCancelRedemption) Type() string { return TypeMsgCancelRedemption } // ValidateBasic Implements Msg. -func (msg MsgCancelQueuedRedemption) ValidateBasic() error { +func (msg MsgCancelRedemption) ValidateBasic() error { errs := make(map[string]error) // check from address @@ -117,7 +121,7 @@ func (msg MsgCancelQueuedRedemption) ValidateBasic() error { // check hash if !hexpr.MatchString(msg.Hash) { - errs["Hash"] = fmt.Errorf("invalid sha256 hash - expecting 64 character hex string") + errs["Hash"] = fmt.Errorf("invalid sha256 hash - expecting 64 character hex string, got %s", msg.Hash) } // validate recipient address @@ -133,12 +137,124 @@ func (msg MsgCancelQueuedRedemption) ValidateBasic() error { } // GetSignBytes Implements Msg. -func (msg MsgCancelQueuedRedemption) GetSignBytes() []byte { +func (msg MsgCancelRedemption) GetSignBytes() []byte { return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(&msg)) } // GetSigners Implements Msg. -func (msg MsgCancelQueuedRedemption) GetSigners() []sdk.AccAddress { +func (msg MsgCancelRedemption) GetSigners() []sdk.AccAddress { + fromAddress, _ := sdk.AccAddressFromBech32(msg.FromAddress) + return []sdk.AccAddress{fromAddress} +} + +// --------------------------------------------------------------- + +func NewMsgRequeueRedemption(chainID string, hash string, fromAddress sdk.Address) *MsgRequeueRedemption { + return &MsgRequeueRedemption{ChainId: chainID, Hash: hash, FromAddress: fromAddress.String()} +} + +// Route Implements Msg. +func (MsgRequeueRedemption) Route() string { return RouterKey } + +// Type Implements Msg. +func (MsgRequeueRedemption) Type() string { return TypeMsgRequeueRedemption } + +// ValidateBasic Implements Msg. +func (msg MsgRequeueRedemption) ValidateBasic() error { + errs := make(map[string]error) + + // check from address + _, err := addressutils.AccAddressFromBech32(msg.FromAddress, "") + if err != nil { + errs["FromAddress"] = err + } + + // check hash + if !hexpr.MatchString(msg.Hash) { + errs["Hash"] = fmt.Errorf("invalid sha256 hash - expecting 64 character hex string, got %s (%d)", msg.Hash, len(msg.Hash)) + } + + // validate recipient address + if msg.ChainId == "" { + errs["ChainId"] = errors.New("chainId not provided") + } + + if len(errs) > 0 { + return multierror.New(errs) + } + + return nil +} + +// GetSignBytes Implements Msg. +func (msg MsgRequeueRedemption) GetSignBytes() []byte { + return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(&msg)) +} + +// GetSigners Implements Msg. +func (msg MsgRequeueRedemption) GetSigners() []sdk.AccAddress { + fromAddress, _ := sdk.AccAddressFromBech32(msg.FromAddress) + return []sdk.AccAddress{fromAddress} +} + +// --------------------------------------------------------------- + +func NewMsgUpdateRedemption(chainID string, hash string, newStatus int32, fromAddress sdk.Address) *MsgUpdateRedemption { + return &MsgUpdateRedemption{ChainId: chainID, Hash: hash, NewStatus: newStatus, FromAddress: fromAddress.String()} +} + +// Route Implements Msg. +func (MsgUpdateRedemption) Route() string { return RouterKey } + +// Type Implements Msg. +func (MsgUpdateRedemption) Type() string { return TypeMsgUpdateRedemption } + +// ValidateBasic Implements Msg. +func (msg MsgUpdateRedemption) ValidateBasic() error { + errs := make(map[string]error) + + // check from address + _, err := addressutils.AccAddressFromBech32(msg.FromAddress, "") + if err != nil { + errs["FromAddress"] = err + } + + // check hash + if !hexpr.MatchString(msg.Hash) { + errs["Hash"] = fmt.Errorf("invalid sha256 hash - expecting 64 character hex string, got %s (%d)", msg.Hash, len(msg.Hash)) + } + + // validate recipient address + if msg.ChainId == "" { + errs["ChainId"] = errors.New("chainId not provided") + } + + switch msg.NewStatus { + case WithdrawStatusTokenize: // intentionally removed as not currently supported, but included here for completeness. + errs["NewStatus"] = errors.New("new status WithdrawStatusTokenize not supported") + case WithdrawStatusQueued: + case WithdrawStatusUnbond: + case WithdrawStatusSend: // send is not a valid state for recovery, included here for completeness. + errs["NewStatus"] = errors.New("new status WithdrawStatusSend not supported") + case WithdrawStatusCompleted: + default: + errs["NewStatus"] = errors.New("new status not provided or invalid") + } + + if len(errs) > 0 { + return multierror.New(errs) + } + + return nil +} + +// GetSignBytes Implements Msg. +func (msg MsgUpdateRedemption) GetSignBytes() []byte { + return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(&msg)) +} + +// GetSigners Implements Msg. +func (msg MsgUpdateRedemption) GetSigners() []sdk.AccAddress { fromAddress, _ := sdk.AccAddressFromBech32(msg.FromAddress) return []sdk.AccAddress{fromAddress} } diff --git a/x/interchainstaking/types/msgs_test.go b/x/interchainstaking/types/msgs_test.go index d5f442ed9..eb532e0fa 100644 --- a/x/interchainstaking/types/msgs_test.go +++ b/x/interchainstaking/types/msgs_test.go @@ -209,7 +209,7 @@ func TestMsgSignalIntent_ValidateBasic(t *testing.T) { } } -func TestMsgCancelQueuedRedemption_ValidateBasic(t *testing.T) { +func TestMsgCancelRedemption_ValidateBasic(t *testing.T) { type fields struct { ChainID string Hash string @@ -229,31 +229,31 @@ func TestMsgCancelQueuedRedemption_ValidateBasic(t *testing.T) { "invalid address", fields{ ChainID: "cosmoshub-4", - Hash: randomutils.GenerateRandomHashAsHex(64), + Hash: randomutils.GenerateRandomHashAsHex(32), FromAddress: "raa", }, true, }, { - "invalid intent - too short", + "invalid hash - too short", fields{ ChainID: "cosmoshub-4", - Hash: randomutils.GenerateRandomHashAsHex(63), + Hash: randomutils.GenerateRandomHashAsHex(31), FromAddress: addressutils.GenerateAddressForTestWithPrefix("quick"), }, true, }, { - "invalid intent - too long", + "invalid hash - too long", fields{ ChainID: "cosmoshub-4", - Hash: randomutils.GenerateRandomHashAsHex(65), + Hash: randomutils.GenerateRandomHashAsHex(33), FromAddress: addressutils.GenerateAddressForTestWithPrefix("quick"), }, true, }, { - "invalid intent - bad chars", + "invalid hash - bad chars", fields{ ChainID: "cosmoshub-4", Hash: "zzzzzzz", @@ -265,7 +265,7 @@ func TestMsgCancelQueuedRedemption_ValidateBasic(t *testing.T) { "invalid chainId", fields{ ChainID: "", - Hash: randomutils.GenerateRandomHashAsHex(64), + Hash: randomutils.GenerateRandomHashAsHex(32), FromAddress: addressutils.GenerateAddressForTestWithPrefix("quick"), }, true, @@ -274,17 +274,144 @@ func TestMsgCancelQueuedRedemption_ValidateBasic(t *testing.T) { "valid", fields{ ChainID: "cosmoshub-4", - Hash: randomutils.GenerateRandomHashAsHex(64), + Hash: randomutils.GenerateRandomHashAsHex(32), + FromAddress: addressutils.GenerateAddressForTestWithPrefix("quick"), + }, + false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + msg := types.MsgCancelRedemption{ + ChainId: tt.fields.ChainID, + Hash: tt.fields.Hash, + FromAddress: tt.fields.FromAddress, + } + err := msg.ValidateBasic() + if tt.wantErr { + t.Logf("Error:\n%v\n", err) + require.Error(t, err) + } else { + require.NoError(t, err) + } + }) + } +} + +func TestMsgUpdateRedemption_ValidateBasic(t *testing.T) { + type fields struct { + ChainID string + Hash string + NewStatus int32 + FromAddress string + } + tests := []struct { + name string + fields fields + wantErr bool + }{ + { + "blank", + fields{}, + true, + }, + { + "invalid address", + fields{ + ChainID: "cosmoshub-4", + Hash: randomutils.GenerateRandomHashAsHex(32), + NewStatus: types.WithdrawStatusQueued, + FromAddress: "raa", + }, + true, + }, + { + "invalid hash - too short", + fields{ + ChainID: "cosmoshub-4", + Hash: randomutils.GenerateRandomHashAsHex(31), + NewStatus: types.WithdrawStatusQueued, + FromAddress: addressutils.GenerateAddressForTestWithPrefix("quick"), + }, + true, + }, + { + "invalid hash - too long", + fields{ + ChainID: "cosmoshub-4", + Hash: randomutils.GenerateRandomHashAsHex(33), + NewStatus: types.WithdrawStatusQueued, FromAddress: addressutils.GenerateAddressForTestWithPrefix("quick"), }, true, }, + { + "invalid hash - bad chars", + fields{ + ChainID: "cosmoshub-4", + Hash: "zzzzzzz", + NewStatus: types.WithdrawStatusQueued, + FromAddress: addressutils.GenerateAddressForTestWithPrefix("quick"), + }, + true, + }, + { + "invalid chainId", + fields{ + ChainID: "", + Hash: randomutils.GenerateRandomHashAsHex(32), + NewStatus: types.WithdrawStatusQueued, + FromAddress: addressutils.GenerateAddressForTestWithPrefix("quick"), + }, + true, + }, + { + "invalid status", + fields{ + ChainID: "cosmoshub-4", + Hash: randomutils.GenerateRandomHashAsHex(32), + NewStatus: 0, + FromAddress: addressutils.GenerateAddressForTestWithPrefix("quick"), + }, + true, + }, + { + "invalid status - send", + fields{ + ChainID: "cosmoshub-4", + Hash: randomutils.GenerateRandomHashAsHex(32), + NewStatus: types.WithdrawStatusSend, + FromAddress: addressutils.GenerateAddressForTestWithPrefix("quick"), + }, + true, + }, + { + "invalid status - tokenize", + fields{ + ChainID: "cosmoshub-4", + Hash: randomutils.GenerateRandomHashAsHex(32), + NewStatus: types.WithdrawStatusTokenize, + FromAddress: addressutils.GenerateAddressForTestWithPrefix("quick"), + }, + true, + }, + { + "valid", + fields{ + ChainID: "cosmoshub-4", + Hash: randomutils.GenerateRandomHashAsHex(32), + NewStatus: types.WithdrawStatusQueued, + FromAddress: addressutils.GenerateAddressForTestWithPrefix("quick"), + }, + false, + }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - msg := types.MsgCancelQueuedRedemption{ + msg := types.MsgUpdateRedemption{ ChainId: tt.fields.ChainID, Hash: tt.fields.Hash, + NewStatus: tt.fields.NewStatus, FromAddress: tt.fields.FromAddress, } err := msg.ValidateBasic() @@ -298,9 +425,146 @@ func TestMsgCancelQueuedRedemption_ValidateBasic(t *testing.T) { } } -func TestMsgCancelQueuedRedemption(t *testing.T) { +func TestMsgRequeueRedemption_ValidateBasic(t *testing.T) { + type fields struct { + ChainID string + Hash string + FromAddress string + } + tests := []struct { + name string + fields fields + wantErr bool + }{ + { + "blank", + fields{}, + true, + }, + { + "invalid address", + fields{ + ChainID: "cosmoshub-4", + Hash: randomutils.GenerateRandomHashAsHex(32), + FromAddress: "raa", + }, + true, + }, + { + "invalid hash - too short", + fields{ + ChainID: "cosmoshub-4", + Hash: randomutils.GenerateRandomHashAsHex(31), + FromAddress: addressutils.GenerateAddressForTestWithPrefix("quick"), + }, + true, + }, + { + "invalid hash - too long", + fields{ + ChainID: "cosmoshub-4", + Hash: randomutils.GenerateRandomHashAsHex(33), + FromAddress: addressutils.GenerateAddressForTestWithPrefix("quick"), + }, + true, + }, + { + "invalid hash - bad chars", + fields{ + ChainID: "cosmoshub-4", + Hash: "zzzzzzz", + FromAddress: addressutils.GenerateAddressForTestWithPrefix("quick"), + }, + true, + }, + { + "invalid chainId", + fields{ + ChainID: "", + Hash: randomutils.GenerateRandomHashAsHex(32), + FromAddress: addressutils.GenerateAddressForTestWithPrefix("quick"), + }, + true, + }, + { + "valid", + fields{ + ChainID: "cosmoshub-4", + Hash: randomutils.GenerateRandomHashAsHex(32), + FromAddress: addressutils.GenerateAddressForTestWithPrefix("quick"), + }, + false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + msg := types.MsgRequeueRedemption{ + ChainId: tt.fields.ChainID, + Hash: tt.fields.Hash, + FromAddress: tt.fields.FromAddress, + } + err := msg.ValidateBasic() + if tt.wantErr { + t.Logf("Error:\n%v\n", err) + require.Error(t, err) + } else { + require.NoError(t, err) + } + }) + } +} + +func TestMsgUpdateRedemption(t *testing.T) { + fromAddr := addressutils.GenerateAccAddressForTest() + msg := types.NewMsgUpdateRedemption("cosmoshub-4", randomutils.GenerateRandomHashAsHex(32), types.WithdrawStatusQueued, fromAddr) + + // Check the router key. + gotRoute := msg.Route() + wantRoute := types.ModuleName + require.Equal(t, wantRoute, gotRoute, "mismatch in route") + + // Check the type. + gotType := msg.Type() + wantType := types.TypeMsgUpdateRedemption + require.Equal(t, wantType, gotType, "mismatch in type") + + // Check the signBytes. + signBytes := msg.GetSignBytes() + require.True(t, len(signBytes) != 0, "expecting signBytes to be produced") + + // Signers should return the from address. + gotSigners := msg.GetSigners() + wantSigners := []sdk.AccAddress{fromAddr} + require.Equal(t, wantSigners, gotSigners, "mismatch in signers") +} + +func TestMsgRequeueRedemption(t *testing.T) { + fromAddr := addressutils.GenerateAccAddressForTest() + msg := types.NewMsgRequeueRedemption("cosmoshub-4", randomutils.GenerateRandomHashAsHex(32), fromAddr) + + // Check the router key. + gotRoute := msg.Route() + wantRoute := types.ModuleName + require.Equal(t, wantRoute, gotRoute, "mismatch in route") + + // Check the type. + gotType := msg.Type() + wantType := types.TypeMsgRequeueRedemption + require.Equal(t, wantType, gotType, "mismatch in type") + + // Check the signBytes. + signBytes := msg.GetSignBytes() + require.True(t, len(signBytes) != 0, "expecting signBytes to be produced") + + // Signers should return the from address. + gotSigners := msg.GetSigners() + wantSigners := []sdk.AccAddress{fromAddr} + require.Equal(t, wantSigners, gotSigners, "mismatch in signers") +} + +func TestMsgCancelRedemption(t *testing.T) { fromAddr := addressutils.GenerateAccAddressForTest() - msg := types.NewMsgCancelQueuedRedemption("cosmoshub-4", randomutils.GenerateRandomHashAsHex(64), fromAddr) + msg := types.NewMsgCancelRedemption("cosmoshub-4", randomutils.GenerateRandomHashAsHex(32), fromAddr) // Check the router key. gotRoute := msg.Route() @@ -309,7 +573,7 @@ func TestMsgCancelQueuedRedemption(t *testing.T) { // Check the type. gotType := msg.Type() - wantType := types.TypeMsgCancelQueuedRedemption + wantType := types.TypeMsgCancelRedemption require.Equal(t, wantType, gotType, "mismatch in type") // Check the signBytes. diff --git a/x/participationrewards/keeper/protocol_data.go b/x/participationrewards/keeper/protocol_data.go index 787f9dc18..55a38d507 100644 --- a/x/participationrewards/keeper/protocol_data.go +++ b/x/participationrewards/keeper/protocol_data.go @@ -51,7 +51,7 @@ func GetAndUnmarshalProtocolData[T any](ctx sdk.Context, k *Keeper, key string, } asType, ok := pd.(T) if !ok { - return dt, tt, fmt.Errorf("could not retrieve type of %T, actual type: %T", (*T)(nil), pd) + return dt, tt, fmt.Errorf("could not retrieve type of %T, actual type: %T", (*T)(nil), pd) } return data, asType, nil } diff --git a/x/participationrewards/types/messages.pb.go b/x/participationrewards/types/messages.pb.go index 5596f44f0..2d7a43fa4 100644 --- a/x/participationrewards/types/messages.pb.go +++ b/x/participationrewards/types/messages.pb.go @@ -122,38 +122,38 @@ func init() { var fileDescriptor_b87e3ea017f90b50 = []byte{ // 513 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x93, 0xb1, 0x6f, 0xd3, 0x4e, - 0x14, 0xc7, 0xe3, 0xa4, 0xbf, 0xaa, 0xbf, 0x2b, 0xea, 0x70, 0x2a, 0xc8, 0x58, 0xc8, 0x8d, 0xd2, - 0x81, 0x08, 0x29, 0x36, 0x71, 0x16, 0xd4, 0x80, 0x04, 0xa5, 0xd0, 0xa9, 0x52, 0xe5, 0x32, 0x31, - 0x10, 0x5d, 0x9c, 0xe3, 0x38, 0x61, 0xfb, 0x1d, 0x77, 0x17, 0xd3, 0x32, 0x32, 0x31, 0x21, 0x24, - 0xfe, 0x81, 0xae, 0xec, 0x2c, 0xfc, 0x07, 0x8c, 0x15, 0x2c, 0x8c, 0x28, 0x01, 0x89, 0x3f, 0x03, - 0xf9, 0xec, 0x56, 0xb6, 0x14, 0xa1, 0x08, 0xb6, 0xbb, 0xe7, 0xfb, 0xbc, 0xf7, 0xfd, 0xbe, 0xf7, - 0x8c, 0x82, 0x17, 0x53, 0x1e, 0x3d, 0x57, 0x3c, 0xce, 0xa8, 0xf4, 0x05, 0x91, 0x9a, 0x47, 0x5c, - 0x10, 0xcd, 0x21, 0x95, 0xf4, 0x25, 0x91, 0x13, 0xe5, 0x67, 0x7d, 0x3f, 0xa1, 0x4a, 0x11, 0x46, - 0x95, 0x27, 0x24, 0x68, 0xc0, 0xdb, 0x15, 0xc6, 0x5b, 0xc4, 0x78, 0x59, 0xdf, 0xb9, 0x1a, 0x81, - 0x4a, 0x40, 0x8d, 0x0c, 0xe2, 0x17, 0x97, 0x82, 0x77, 0x36, 0x19, 0x30, 0x28, 0xe2, 0xf9, 0xa9, - 0x8c, 0x5e, 0x63, 0x00, 0x2c, 0xa6, 0x3e, 0x11, 0xdc, 0x27, 0x69, 0x0a, 0xda, 0x64, 0x3c, 0x67, - 0x6e, 0x56, 0x75, 0x46, 0x31, 0xe1, 0x89, 0x4a, 0x48, 0x4a, 0x18, 0x95, 0xb9, 0xc0, 0x5a, 0xa0, - 0x24, 0x06, 0xcb, 0x38, 0x13, 0x12, 0x04, 0x28, 0x12, 0x97, 0x65, 0x3a, 0x6f, 0x9b, 0x68, 0xe3, - 0x40, 0xb1, 0xa3, 0xe9, 0x38, 0xe1, 0xfa, 0x7e, 0x9e, 0x15, 0xdf, 0x46, 0x97, 0xa6, 0x8a, 0xca, - 0x11, 0x99, 0x4c, 0x24, 0x55, 0xca, 0xb6, 0xda, 0x56, 0xf7, 0xff, 0x5d, 0xfb, 0xcb, 0xc7, 0xde, - 0x66, 0xe9, 0xea, 0x5e, 0xf1, 0xe5, 0x48, 0x4b, 0x9e, 0xb2, 0xb0, 0xf6, 0x1a, 0x63, 0xb4, 0xf2, - 0x0a, 0x52, 0x6a, 0x37, 0x73, 0x2a, 0x34, 0x67, 0xec, 0xa0, 0x35, 0x25, 0xa3, 0x91, 0x89, 0xb7, - 0x4c, 0xfc, 0xe2, 0x8e, 0xf7, 0x11, 0x32, 0x66, 0x46, 0xfa, 0x44, 0x50, 0x7b, 0xa5, 0x6d, 0x75, - 0x37, 0x82, 0xeb, 0x5e, 0xb5, 0xe1, 0x75, 0xaf, 0x59, 0xdf, 0x33, 0x32, 0x1f, 0x9d, 0x08, 0x1a, - 0x56, 0x50, 0x3c, 0x44, 0xab, 0x42, 0x02, 0x3c, 0x55, 0xf6, 0x7f, 0xed, 0x56, 0x77, 0x3d, 0xd8, - 0xfe, 0x73, 0x92, 0xc3, 0xfc, 0x6d, 0x58, 0x22, 0x3b, 0x6b, 0x6f, 0x4e, 0xb7, 0x1a, 0xbf, 0x4e, - 0xb7, 0x1a, 0x1d, 0x1b, 0x5d, 0xa9, 0xf7, 0x23, 0xa4, 0x4a, 0x40, 0xaa, 0x68, 0xf0, 0xa1, 0x85, - 0x5a, 0x07, 0x8a, 0xe1, 0x4f, 0x16, 0x5a, 0xaf, 0xf6, 0x6b, 0xe0, 0x2d, 0xb1, 0x1e, 0x5e, 0x3d, - 0xa9, 0x33, 0xfc, 0x0b, 0xe8, 0x5c, 0x49, 0xe7, 0xd6, 0xeb, 0xaf, 0x3f, 0xde, 0x37, 0x83, 0x1d, - 0xeb, 0x46, 0xa7, 0xe7, 0x57, 0xa7, 0xae, 0x8f, 0xcd, 0x8c, 0x17, 0xcd, 0xde, 0x34, 0x00, 0xff, - 0xb4, 0xd0, 0xe5, 0x7d, 0xc8, 0x42, 0x9a, 0x40, 0x46, 0x0f, 0xf3, 0x0d, 0x88, 0x20, 0xde, 0x23, - 0x9a, 0xe0, 0x3b, 0xcb, 0x0a, 0x5a, 0x88, 0x3b, 0x0f, 0xfe, 0x09, 0xbf, 0x70, 0xf6, 0xd0, 0x38, - 0xbb, 0x9b, 0x3b, 0x1b, 0x2e, 0xeb, 0x4c, 0x9a, 0x74, 0xc5, 0x7f, 0x17, 0x41, 0x3c, 0x21, 0x9a, - 0xec, 0x3e, 0xf9, 0x3c, 0x73, 0xad, 0xb3, 0x99, 0x6b, 0x7d, 0x9f, 0xb9, 0xd6, 0xbb, 0xb9, 0xdb, - 0x38, 0x9b, 0xbb, 0x8d, 0x6f, 0x73, 0xb7, 0xf1, 0x78, 0x8f, 0x71, 0xfd, 0x6c, 0x3a, 0xf6, 0x22, - 0x48, 0xaa, 0x05, 0x7a, 0xf9, 0x32, 0xd6, 0x2a, 0x1e, 0x2f, 0xae, 0x96, 0xef, 0x9a, 0x1a, 0xaf, - 0x9a, 0x6a, 0x83, 0xdf, 0x01, 0x00, 0x00, 0xff, 0xff, 0xe2, 0xd7, 0x14, 0x51, 0x4e, 0x04, 0x00, + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x93, 0x41, 0x6b, 0x13, 0x41, + 0x14, 0xc7, 0x33, 0x49, 0x2d, 0x75, 0x2a, 0x3d, 0x0c, 0x55, 0xd6, 0x20, 0xdb, 0x90, 0x1e, 0x0c, + 0x85, 0xec, 0x9a, 0xe4, 0x22, 0x89, 0x82, 0xd6, 0x6a, 0x4f, 0x85, 0xb2, 0xf5, 0xe4, 0xc1, 0x30, + 0xd9, 0x8c, 0xe3, 0xe0, 0xee, 0xbe, 0x71, 0x66, 0xb2, 0xb6, 0x1e, 0x3d, 0x79, 0x12, 0xc1, 0x2f, + 0xd0, 0xab, 0x77, 0x2f, 0x7e, 0x03, 0x8f, 0x45, 0x2f, 0x1e, 0x25, 0x51, 0xf0, 0x63, 0xc8, 0x4e, + 0xb6, 0x65, 0x17, 0x82, 0x04, 0xbd, 0xcd, 0xbc, 0x9d, 0xdf, 0x7b, 0xff, 0xff, 0x7b, 0x6f, 0x71, + 0xf7, 0xe5, 0x44, 0x84, 0x2f, 0xb4, 0x88, 0x52, 0xa6, 0x7c, 0x49, 0x95, 0x11, 0xa1, 0x90, 0xd4, + 0x08, 0x48, 0x14, 0x7b, 0x45, 0xd5, 0x58, 0xfb, 0x69, 0xc7, 0x8f, 0x99, 0xd6, 0x94, 0x33, 0xed, + 0x49, 0x05, 0x06, 0xc8, 0x76, 0x81, 0xf1, 0x16, 0x31, 0x5e, 0xda, 0xa9, 0x5f, 0x0f, 0x41, 0xc7, + 0xa0, 0x87, 0x16, 0xf1, 0xe7, 0x97, 0x39, 0x5f, 0xdf, 0xe4, 0xc0, 0x61, 0x1e, 0xcf, 0x4e, 0x79, + 0xf4, 0x06, 0x07, 0xe0, 0x11, 0xf3, 0xa9, 0x14, 0x3e, 0x4d, 0x12, 0x30, 0x36, 0xe3, 0x39, 0x73, + 0xab, 0xa8, 0x33, 0x8c, 0xa8, 0x88, 0x75, 0x4c, 0x13, 0xca, 0x99, 0xca, 0x04, 0x96, 0x02, 0x39, + 0xd1, 0x5b, 0xc6, 0x99, 0x54, 0x20, 0x41, 0xd3, 0x28, 0x2f, 0xd3, 0x7c, 0x57, 0xc5, 0x1b, 0x07, + 0x9a, 0x1f, 0x4d, 0x46, 0xb1, 0x30, 0x0f, 0xb2, 0xac, 0xe4, 0x0e, 0xbe, 0x32, 0xd1, 0x4c, 0x0d, + 0xe9, 0x78, 0xac, 0x98, 0xd6, 0x0e, 0x6a, 0xa0, 0xd6, 0xe5, 0x5d, 0xe7, 0xeb, 0xa7, 0xf6, 0x66, + 0xee, 0xea, 0xfe, 0xfc, 0xcb, 0x91, 0x51, 0x22, 0xe1, 0x41, 0xe9, 0x35, 0x21, 0x78, 0xe5, 0x35, + 0x24, 0xcc, 0xa9, 0x66, 0x54, 0x60, 0xcf, 0xa4, 0x8e, 0xd7, 0xb4, 0x0a, 0x87, 0x36, 0x5e, 0xb3, + 0xf1, 0x8b, 0x3b, 0xd9, 0xc7, 0xd8, 0x9a, 0x19, 0x9a, 0x13, 0xc9, 0x9c, 0x95, 0x06, 0x6a, 0x6d, + 0x74, 0x6f, 0x7a, 0xc5, 0x86, 0x97, 0xbd, 0xa6, 0x1d, 0xcf, 0xca, 0x7c, 0x7c, 0x22, 0x59, 0x50, + 0x40, 0xc9, 0x00, 0xaf, 0x4a, 0x05, 0xf0, 0x4c, 0x3b, 0x97, 0x1a, 0xb5, 0xd6, 0x7a, 0x77, 0xfb, + 0xef, 0x49, 0x0e, 0xb3, 0xb7, 0x41, 0x8e, 0xf4, 0xd7, 0xde, 0x9e, 0x6e, 0x55, 0x7e, 0x9f, 0x6e, + 0x55, 0x9a, 0x0e, 0xbe, 0x56, 0xee, 0x47, 0xc0, 0xb4, 0x84, 0x44, 0xb3, 0xee, 0xc7, 0x1a, 0xae, + 0x1d, 0x68, 0x4e, 0x3e, 0x23, 0xbc, 0x5e, 0xec, 0x57, 0xcf, 0x5b, 0x62, 0x3d, 0xbc, 0x72, 0xd2, + 0xfa, 0xe0, 0x1f, 0xa0, 0x73, 0x25, 0xcd, 0xdb, 0x6f, 0xbe, 0xfd, 0xfc, 0x50, 0xed, 0x36, 0xdb, + 0x7e, 0x71, 0xe4, 0xe6, 0xd8, 0x0e, 0x78, 0xd1, 0xe0, 0xad, 0xfb, 0x3e, 0xda, 0x21, 0xbf, 0x10, + 0xbe, 0xba, 0x0f, 0x69, 0xc0, 0x62, 0x48, 0xd9, 0x61, 0xb6, 0x01, 0x21, 0x44, 0x7b, 0xd4, 0x50, + 0x72, 0x77, 0x59, 0x41, 0x0b, 0xf1, 0xfa, 0xc3, 0xff, 0xc2, 0x2f, 0x9c, 0x3d, 0xb2, 0xce, 0xee, + 0x35, 0x07, 0xcb, 0x3a, 0x53, 0x36, 0xd7, 0xfc, 0xa7, 0x0b, 0x21, 0x1a, 0x53, 0x43, 0xfb, 0x68, + 0x67, 0xf7, 0xe9, 0x97, 0xa9, 0x8b, 0xce, 0xa6, 0x2e, 0xfa, 0x31, 0x75, 0xd1, 0xfb, 0x99, 0x5b, + 0x39, 0x9b, 0xb9, 0x95, 0xef, 0x33, 0xb7, 0xf2, 0x64, 0x8f, 0x0b, 0xf3, 0x7c, 0x32, 0xf2, 0x42, + 0x88, 0x8b, 0x35, 0xda, 0xd9, 0x32, 0x96, 0x8a, 0x1e, 0x2f, 0x2e, 0x98, 0xed, 0x9a, 0x1e, 0xad, + 0xda, 0x82, 0xbd, 0x3f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x88, 0xb9, 0xa5, 0xbf, 0x4e, 0x04, 0x00, 0x00, }