From 9993613f2de62c1e3524e66bc85413607bd7bfa4 Mon Sep 17 00:00:00 2001 From: mbreithecker Date: Wed, 30 Jul 2025 13:28:16 +0200 Subject: [PATCH 1/8] feat: add liquid module --- x/liquid/LICENSE | 201 + x/liquid/README.md | 1427 +++++ x/liquid/autocli.go | 117 + x/liquid/client/cli/tx.go | 338 ++ x/liquid/keeper/abci.go | 14 + x/liquid/keeper/distribution.go | 215 + x/liquid/keeper/genesis.go | 85 + x/liquid/keeper/grpc_query.go | 334 ++ x/liquid/keeper/grpc_query_test.go | 187 + x/liquid/keeper/hooks.go | 97 + x/liquid/keeper/keeper.go | 61 + x/liquid/keeper/keeper_test.go | 105 + x/liquid/keeper/liquid_stake.go | 488 ++ x/liquid/keeper/liquid_stake_test.go | 716 +++ x/liquid/keeper/msg_server.go | 513 ++ x/liquid/keeper/params.go | 48 + x/liquid/keeper/tokenize_share_record.go | 196 + x/liquid/keeper/tokenize_share_record_test.go | 64 + x/liquid/module.go | 217 + x/liquid/types/codec.go | 44 + x/liquid/types/errors.go | 24 + x/liquid/types/events.go | 17 + x/liquid/types/expected_keepers.go | 64 + x/liquid/types/genesis.go | 29 + x/liquid/types/genesis.pb.go | 833 +++ x/liquid/types/keys.go | 73 + x/liquid/types/liquid.pb.go | 1407 +++++ x/liquid/types/liquid_validator.go | 25 + x/liquid/types/mocks/AccountKeeper.go | 234 + x/liquid/types/mocks/BankKeeper.go | 572 ++ x/liquid/types/mocks/DistributionKeeper.go | 219 + x/liquid/types/mocks/StakingKeeper.go | 953 ++++ x/liquid/types/msg.go | 23 + x/liquid/types/params.go | 97 + x/liquid/types/query.pb.go | 4945 +++++++++++++++++ x/liquid/types/query.pb.gw.go | 1120 ++++ x/liquid/types/tokenize_share_record.go | 22 + x/liquid/types/tx.pb.go | 3374 +++++++++++ 38 files changed, 19498 insertions(+) create mode 100644 x/liquid/LICENSE create mode 100644 x/liquid/README.md create mode 100644 x/liquid/autocli.go create mode 100644 x/liquid/client/cli/tx.go create mode 100644 x/liquid/keeper/abci.go create mode 100644 x/liquid/keeper/distribution.go create mode 100644 x/liquid/keeper/genesis.go create mode 100644 x/liquid/keeper/grpc_query.go create mode 100644 x/liquid/keeper/grpc_query_test.go create mode 100644 x/liquid/keeper/hooks.go create mode 100644 x/liquid/keeper/keeper.go create mode 100644 x/liquid/keeper/keeper_test.go create mode 100644 x/liquid/keeper/liquid_stake.go create mode 100644 x/liquid/keeper/liquid_stake_test.go create mode 100644 x/liquid/keeper/msg_server.go create mode 100644 x/liquid/keeper/params.go create mode 100644 x/liquid/keeper/tokenize_share_record.go create mode 100644 x/liquid/keeper/tokenize_share_record_test.go create mode 100644 x/liquid/module.go create mode 100644 x/liquid/types/codec.go create mode 100644 x/liquid/types/errors.go create mode 100644 x/liquid/types/events.go create mode 100644 x/liquid/types/expected_keepers.go create mode 100644 x/liquid/types/genesis.go create mode 100644 x/liquid/types/genesis.pb.go create mode 100644 x/liquid/types/keys.go create mode 100644 x/liquid/types/liquid.pb.go create mode 100644 x/liquid/types/liquid_validator.go create mode 100644 x/liquid/types/mocks/AccountKeeper.go create mode 100644 x/liquid/types/mocks/BankKeeper.go create mode 100644 x/liquid/types/mocks/DistributionKeeper.go create mode 100644 x/liquid/types/mocks/StakingKeeper.go create mode 100644 x/liquid/types/msg.go create mode 100644 x/liquid/types/params.go create mode 100644 x/liquid/types/query.pb.go create mode 100644 x/liquid/types/query.pb.gw.go create mode 100644 x/liquid/types/tokenize_share_record.go create mode 100644 x/liquid/types/tx.pb.go diff --git a/x/liquid/LICENSE b/x/liquid/LICENSE new file mode 100644 index 00000000..b00fda25 --- /dev/null +++ b/x/liquid/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright 2016 the Gaia authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. \ No newline at end of file diff --git a/x/liquid/README.md b/x/liquid/README.md new file mode 100644 index 00000000..39abe3ec --- /dev/null +++ b/x/liquid/README.md @@ -0,0 +1,1427 @@ +# `x/liquid` + +## Abstract + +This module enables the Cosmos Hub to support the issuance of native liquid staking denoms. + + +## Contents + +* [State](#state) + * [TotalLiquidStakedTokens](#totalliquidstakedtokens) + * [PendingTokenizeShareAuthorizations](#pendingtokenizeshareauthorizations) +* [Messages](#messages) + * [MsgUpdateParams](#msgupdateparams) + * [MsgTokenizeShares](#msgtokenizeshares) + * [MsgRedeemTokensForShares](#msgredeemtokensforshares) + * [MsgTransferTokenizeShareRecord](#msgtransfertokenizesharerecord) + * [MsgEnableTokenizeShares](#msgenabletokenizeshares) + * [MsgDisableTokenizeShares](#msgdisabletokenizeshares) + * [MsgWithdrawTokenizeShareRecordReward](#msgwithdrawtokenizesharerecordreward) + * [MsgWithdrawAllTokenizeShareRecordReward](#msgwithdrawalltokenizesharerecordreward) +* [Begin-Block](#begin-block) + * [Expire Tokenize Share Locks](#removeexpiredtokenizesharelocks) +* [Events](#events) + * [EndBlocker](#endblocker) + * [Msg's](#msgs) +* [Parameters](#parameters) +* [Client](#client) + * [CLI](#cli) + * [gRPC](#grpc) + * [REST](#rest) + +## State + +### Params + +The liquid module stores its params in state with the prefix of `0x51`, +it can be updated with governance or the address with authority. + +* Params: `0x51 | ProtocolBuffer(Params)` + +```protobuf +// Params defines the parameters for the x/liquid module. +message Params { + option (amino.name) = "gaia/x/liquid/Params"; + option (gogoproto.equal) = true; + + // global_liquid_staking_cap represents a cap on the portion of stake that + // comes from liquid staking providers + string global_liquid_staking_cap = 8 [ + (gogoproto.moretags) = "yaml:\"global_liquid_staking_cap\"", + (gogoproto.customtype) = "cosmossdk.io/math.LegacyDec", + (gogoproto.nullable) = false, + (amino.dont_omitempty) = true, + (cosmos_proto.scalar) = "cosmos.Dec" + ]; + // validator_liquid_staking_cap represents a cap on the portion of stake that + // comes from liquid staking providers for a specific validator + string validator_liquid_staking_cap = 9 [ + (gogoproto.moretags) = "yaml:\"validator_liquid_staking_cap\"", + (gogoproto.customtype) = "cosmossdk.io/math.LegacyDec", + (gogoproto.nullable) = false, + (amino.dont_omitempty) = true, + (cosmos_proto.scalar) = "cosmos.Dec" + ]; +} +``` + +### TotalLiquidStakedTokens + +TotalLiquidStakedTokens stores the total liquid staked tokens monitoring the progress towards the `GlobalLiquidStakingCap`. + +* TotalLiquidStakedTokens: `0x5 -> math.Int`. + + +### PendingTokenizeShareAuthorizations + +PendingTokenizeShareAuthorizations stores a queue of addresses that have their tokenize share re-enablement/unlocking in progress. When an address is enqueued, it will sit for 1 unbonding period before the tokenize share lock is removed. + +```protobuf +// PendingTokenizeShareAuthorizations stores a list of addresses that have their +// tokenize share enablement in progress +message PendingTokenizeShareAuthorizations { repeated string addresses = 1; } +``` + +## Messages + +In this section we describe the processing of the liquid messages and the corresponding updates to the state. All created/modified state objects specified by each message are defined within the [state](#state) section. + +## MsgTokenizeShares + +The `MsgTokenizeShares` message allows users to tokenize their delegated tokens. Created denoms combine the validator +address and record id of the underlying delegation, i.e. the denom of a created token would look like the following: ` +{validatorAddress}/{recordId}`. + +```protobuf +// MsgTokenizeShares tokenizes a delegation +message MsgTokenizeShares { + option (cosmos.msg.v1.signer) = "delegator_address"; + option (amino.name) = "gaia/MsgTokenizeShares"; + + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string delegator_address = 1 + [ (gogoproto.moretags) = "yaml:\"delegator_address\"" ]; + string validator_address = 2 + [ (gogoproto.moretags) = "yaml:\"validator_address\"" ]; + cosmos.base.v1beta1.Coin amount = 3 [ (gogoproto.nullable) = false ]; + string tokenized_share_owner = 4; +} +``` + +This message returns a response containing the number of tokens generated: + +```protobuf +// MsgTokenizeSharesResponse defines the Msg/MsgTokenizeShares response type. +message MsgTokenizeSharesResponse { + cosmos.base.v1beta1.Coin amount = 1 [ (gogoproto.nullable) = false ]; +} +``` + +This message is expected to fail if: + +* The delegator sender's address has disabled tokenization, meaning that the account +lock status is either `LOCKED` or `LOCK_EXPIRING`. +* The account is a vesting account and the free delegation (non-vesting delegation) is exceeding the tokenized share amount. +* The tokenized shares exceeds either the `GlobalLiquidStakingCap`, the `ValidatorLiquidStakingCap`. + + +When this message is processed the following actions occur: + +* Increment the `GlobalLiquidStakingCap` +* Increment the validator's `ValidatorLiquidStakingCap` +* Unbond the delegation shares and transfer the coins back to delegator +* Create an equivalent amount of tokenized shares that the initial delegation shares +* Mint the liquid coins and send them to delegator +* Create a tokenized share record +* Get validator to whom the sender delegated his shares +* Send coins to module address and delegate them to the validator + +## MsgRedeemTokensForShares + +The `MsgRedeemTokensForShares` message allows users to redeem their native delegations from share tokens. + + +```protobuf +// MsgRedeemTokensForShares redeems a tokenized share back into a native +// delegation +message MsgRedeemTokensForShares { + option (cosmos.msg.v1.signer) = "delegator_address"; + option (amino.name) = "gaia/MsgRedeemTokensForShares"; + + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string delegator_address = 1 + [ (gogoproto.moretags) = "yaml:\"delegator_address\"" ]; + cosmos.base.v1beta1.Coin amount = 2 [ (gogoproto.nullable) = false ]; +} +``` + +This message returns a response containing the amount of staked tokens redeemed: + +```protobuf +// MsgRedeemTokensForSharesResponse defines the Msg/MsgRedeemTokensForShares +// response type. +message MsgRedeemTokensForSharesResponse { + cosmos.base.v1beta1.Coin amount = 1 [ (gogoproto.nullable) = false ]; +} +``` + +This message is expected to fail if: + +* If the sender's balance doesn't have enough liquid tokens + + +When this message is processed the following actions occur: + +* Get the tokenized shares record +* Get the validator that issued the tokenized shares from the record +* Unbond the delegation associated with the tokenized shares +* Decrease the `ValidatorLiquidStakingCap` +* Decrease the validator's `LiquidShares` +* Burn the liquid coins equivalent of the tokenized shares +* Delete the tokenized shares record +* Send equivalent amount of tokens to the delegator +* Delegate sender's tokens to the validator + +## MsgTransferTokenizeShareRecord + +The `MsgTransferTokenizeShareRecord` message enables users to transfer the ownership of rewards generated from the tokenized amount of delegation. + +```protobuf +// MsgTransferTokenizeShareRecord transfer a tokenize share record +message MsgTransferTokenizeShareRecord { + option (cosmos.msg.v1.signer) = "sender"; + option (amino.name) = "gaia/MsgTransferTokenizeShareRecord"; + + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + uint64 tokenize_share_record_id = 1; + string sender = 2; + string new_owner = 3; +} +``` + +This message is expected to fail if: + +* The tokenized shares record doesn't exist +* The sender address doesn't match the owner address in the record + +When this message is processed the following actions occur: + +* The tokenized shares record is updated with the new owner address + +## MsgEnableTokenizeShares + +The `MsgEnableTokenizeShares` message begins the countdown after which tokenizing shares by the sender delegator address is re-allowed, which will complete after the unbonding period. + + +```protobuf +// MsgEnableTokenizeShares re-enables tokenization of shares for a given address +message MsgEnableTokenizeShares { + option (cosmos.msg.v1.signer) = "delegator_address"; + option (amino.name) = "gaia/MsgEnableTokenizeShares"; + + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string delegator_address = 1 + [ (gogoproto.moretags) = "yaml:\"delegator_address\"" ]; +} +``` + + +This message returns a response containing the time at which the lock is completely removed: + +```protobuf +// MsgEnableTokenizeSharesResponse defines the Msg/EnableTokenizeShares response +// type. +message MsgEnableTokenizeSharesResponse { + google.protobuf.Timestamp completion_time = 1 + [ (gogoproto.nullable) = false, (gogoproto.stdtime) = true ]; +} +``` + +This message is expected to fail if: + +* If the sender's account lock status is either equal to `UNLOCKED` or `LOCK_EXPIRING`, +meaning that the tokenized shares aren't currently disabled. + + +When this message is processed the following actions occur: + +* Queue the unlock authorization. + +## MsgDisableTokenizeShares + +The `MsgDisableTokenizeShares` message prevents the sender delegator address from tokenizing any of its delegations. + +```protobuf +// MsgDisableTokenizeShares prevents the tokenization of shares for a given +// address +message MsgDisableTokenizeShares { + option (cosmos.msg.v1.signer) = "delegator_address"; + option (amino.name) = "gaia/MsgDisableTokenizeShares"; + + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string delegator_address = 1 + [ (gogoproto.moretags) = "yaml:\"delegator_address\"" ]; +} +``` + +This message is expected to fail if: + +* The sender's account already has the `LOCKED` lock status + + +When this message is processed the following actions occur: + +* If the sender's account lock status is equal to `LOCK_EXPIRING`, +it cancels the pending unlock authorizations by removing them from the queue. +* Create a new tokenization lock for the sender's account. Note that +if there is a lock expiration in progress, it is overridden. + +### MsgUpdateParams + +The `MsgUpdateParams` updates the liquid module parameters. +The params are updated through a governance proposal where the signer is the gov module account address. + +```protobuf +// MsgUpdateParams is the Msg/UpdateParams request type. +message MsgUpdateParams { + option (cosmos.msg.v1.signer) = "authority"; + option (amino.name) = "gaia/liquid/MsgUpdateParams"; + + // authority is the address that controls the module (defaults to x/gov unless + // overwritten). + string authority = 1 [ (cosmos_proto.scalar) = "cosmos.AddressString" ]; + // params defines the x/liquid parameters to update. + // + // NOTE: All parameters must be supplied. + Params params = 2 + [ (gogoproto.nullable) = false, (amino.dont_omitempty) = true ]; +}; +``` + +The message handling can fail if: + +* Signer is not the authority defined in the liquid keeper (usually the gov module account). + +### MsgWithdrawTokenizeShareRecordReward + +The `MsgWithdrawTokenizeShareRecordReward` withdraws distribution rewards that have been distributed to the owner of +a single tokenize share record. + +```protobuf +// MsgWithdrawTokenizeShareRecordReward withdraws tokenize share rewards for a +// specific record +message MsgWithdrawTokenizeShareRecordReward { + option (cosmos.msg.v1.signer) = "owner_address"; + option (amino.name) = "gaia/MsgWithdrawTokenizeShareRecordReward"; + + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string owner_address = 1 [ (gogoproto.moretags) = "yaml:\"owner_address\"" ]; + uint64 record_id = 2; +} +``` + +The message handling can fail if: + +* Signer is not the owner of the tokenize share record. + +### MsgWithdrawAllTokenizeShareRecordReward + +The `MsgWithdrawAllTokenizeShareRecordReward` withdraws distribution rewards that have been distributed to the owner for +any tokenize share record they own. + +```protobuf +// MsgWithdrawAllTokenizeShareRecordReward withdraws tokenize share rewards or +// all records owned by the designated owner +message MsgWithdrawAllTokenizeShareRecordReward { + option (cosmos.msg.v1.signer) = "owner_address"; + option (amino.name) = "gaia/MsgWithdrawAllTokenizeShareRecordReward"; + + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string owner_address = 1 [ (gogoproto.moretags) = "yaml:\"owner_address\"" ]; +} +``` + +The message handling can fail if: + +* Signer is not the owner of the tokenize share record. + +## Begin-Block + +### RemoveExpiredTokenizeShareLocks +Each abci begin block call, the liquid module will prune expired tokenize share locks. + + +## Events + +The liquid module emits the following events: + +## Msg's + +### MsgTokenizeShares + +| Type | Attribute Key | Attribute Value | +| ----------------------------- |-----------------------|------------------------------| +| tokenize_shares | delegator_address | {delegatorAddress} | +| tokenize_shares | validator_address | {validatorAddress} | +| tokenize_shares | tokenized_share_owner | {tokenizedShareOwnerAddress} | +| tokenize_shares | amount | {tokenizeAmount} | +| message | module | liquid | +| message | action | tokenize_shares | +| message | sender | {senderAddress} | + +### MsgRedeemTokensForShares + +| Type | Attribute Key | Attribute Value | +| ----------------------------- |-------------------|--------------------| +| redeem_tokens_for_shares | delegator_address | {delegatorAddress} | +| redeem_tokens_for_shares | amount | {redeemAmount} | +| message | module | liquid | +| message | action | redeem_tokens | +| message | sender | {senderAddress} | + +### MsgTransferTokenizeShareRecord + +| Type | Attribute Key | Attribute Value | +| ---------------------------------- |--------------------------|--------------------------------| +| transfer_tokenize_share_record | tokenize_share_record_id | {shareRecordID} | +| transfer_tokenize_share_record | sender | {senderAddress} | +| transfer_tokenize_share_record | new_owner | {newShareOwnerAddress} | +| message | module | liquid | +| message | action | transfer-tokenize-share-record | +| message | sender | {senderAddress} | + +### MsgEnableTokenizeShares + +| Type | Attribute Key | Attribute Value | +| ----------------------------- |-------------------|------------------------| +| enable_tokenize_shares | delegator_address | {delegatorAddress} | +| message | module | liquid | +| message | action | enable_tokenize_shares | +| message | sender | {senderAddress} | + +### MsgDisableTokenizeShares + +| Type | Attribute Key | Attribute Value | +| ----------------------------- |-------------------|-------------------------| +| disable_tokenize_shares | delegator_address | {delegatorAddress} | +| message | module | liquid | +| message | action | disable_tokenize_shares | +| message | sender | {senderAddress} | + +### MsgWithdrawTokenizeShareRecordReward + +| Type | Attribute Key | Attribute Value | +|---------------------------------------|---------------|---------------------------------------| +| withdraw_tokenize_share_record_reward | owner_address | {ownerAddress} | +| withdraw_tokenize_share_record_reward | record_id | {recordID} | +| message | module | liquid | +| message | action | withdraw_tokenize_share_record_reward | +| message | sender | {senderAddress} | + +### MsgWithdrawAllTokenizeShareRecordReward + +| Type | Attribute Key | Attribute Value | +|-------------------------------------------|---------------|-------------------------------------------| +| withdraw_all_tokenize_share_record_reward | owner_address | {ownerAddress} | +| message | module | liquid | +| message | action | withdraw_all_tokenize_share_record_reward | +| message | sender | {senderAddress} | + + +## Parameters + +The liquid module contains the following parameters: + +| Key | Type | Example | +|------------------------- |------------------|--------------------------| +| GlobalLiquidStakingCap | string | "1.000000000000000000" | +| ValidatorLiquidStakingCap | string | "0.250000000000000000" | + + +## Client + +### CLI + +A user can query and interact with the `liquid` module using the CLI. + +#### Query + +The `query` commands allows users to query `liquid` state. + +```bash +gaiad query liquid --help +``` + +##### all-tokenize-share-records + +The `all-tokenize-share-records` command allows users to query all tokenize share records. + +Usage: + +```bash +gaiad query liquid all-tokenize-share-records [flags] +``` + +Example: + +```bash +gaiad query liquid all-tokenize-share-records +``` + +Example Output: + +```bash +pagination: + total: "1" +records: +- id: "1" + module_account: tokenizeshare_1 + owner: cosmos1dw6s9qsz4uh42j3cgapyfm3tu83qafchy2srez + validator: cosmosvaloper1dw6s9qsz4uh42j3cgapyfm3tu83qafchp7yk43 +``` + +##### last-tokenize-share-record-id + +The `last-tokenize-share-record-id` command allows users to query the last tokenize share record ID issued. + +Usage: + +```bash +gaiad query liquid last-tokenize-share-record-id [flags] +``` + +Example: + +```bash +gaiad query liquid last-tokenize-share-record-id +``` + +Example Output: + +```bash +id: "2" +``` + +##### params + +The `params` command allows users to query the current module params. + +Usage: + +```bash +gaiad query liquid params [flags] +``` + +Example: + +```bash +gaiad query liquid params +``` + +Example Output: + +```bash +params: + global_liquid_staking_cap: "0.250000000000000000" + validator_liquid_staking_cap: "1.000000000000000000" +``` + +##### tokenize-share-lock-info + +The `tokenize-share-lock-info` command allows users to query the current tokenization lock status for a given account. + +Usage: + +```bash +gaiad query liquid tokenize-share-lock-info [account-addr] [flags] +``` + +Example: + +```bash +gaiad query liquid tokenize-share-lock-info cosmos1dw6s9qsz4uh42j3cgapyfm3tu83qafchy2srez +``` + +Example Output: + +```bash +status: TOKENIZE_SHARE_LOCK_STATUS_UNLOCKED +``` + + +##### tokenize-share-record-by-denom + +The `tokenize-share-record-by-denom` command allows users to query the tokenize share record information for the +provided denom. + +Usage: + +```bash +gaiad query liquid tokenize-share-record-by-denom [denom] [flags] +``` + +Example: + +```bash +gaiad query liquid tokenize-share-record-by-denom cosmosvaloper1vuvl27z833dksv89vz2205mrwhadez3k3egzrh/1 +``` + +Example Output: + +```bash +record: + id: "1" + module_account: tokenizeshare_1 + owner: cosmos15ty20clrlwmph2v8k7qzr4lklpz883zdd89ckp + validator: cosmosvaloper1vuvl27z833dksv89vz2205mrwhadez3k3egzrh +``` + +##### tokenize-share-record-by-id + +The `tokenize-share-record-by-id` command allows users to query the tokenize share record information for the +provided record ID. + +Usage: + +```bash +gaiad query liquid tokenize-share-record-by-id [ID] [flags] +``` + +Example: + +```bash +gaiad query liquid tokenize-share-record-by-id 1 +``` + +Example Output: + +```bash +record: + id: "1" + module_account: tokenizeshare_1 + owner: cosmos15ty20clrlwmph2v8k7qzr4lklpz883zdd89ckp + validator: cosmosvaloper1vuvl27z833dksv89vz2205mrwhadez3k3egzrh +``` + +##### tokenize-share-record-rewards + +The `tokenize-share-record-rewards` command allows users to query the rewards for the provided record owner. + +Usage: + +```bash +gaiad query liquid tokenize-share-record-rewards [owner-addr] [flags] +``` + +Example: + +```bash +gaiad query liquid tokenize-share-record-rewards cosmos15ty20clrlwmph2v8k7qzr4lklpz883zdd89ckp +``` + +Example Output: + +```bash +rewards: + - record_id: "1" + reward: + - 1496874162.803718702000000000stake + - 2.155511221800000000uatom +total: +- 1496874162.803718702000000000stake +- 2.155511221800000000uatom +``` + +##### tokenize-share-records-owned + +The `tokenize-share-records-owned` command allows users to query the records account address. + +Usage: + +```bash +gaiad query liquid tokenize-share-records-owned [owner-addr] [flags] +``` + +Example: + +```bash +gaiad query liquid tokenize-share-records-owned cosmos15ty20clrlwmph2v8k7qzr4lklpz883zdd89ckp +``` + +Example Output: + +```bash +records: +- id: "1" + module_account: tokenizeshare_1 + owner: cosmos15ty20clrlwmph2v8k7qzr4lklpz883zdd89ckp + validator: cosmosvaloper1vuvl27z833dksv89vz2205mrwhadez3k3egzrh +``` + +##### total-liquid-staked + +The `total-liquid-staked` command allows users to query the total amount of tokens liquid staked. + +Usage: + +```bash +gaiad query liquid total-liquid-staked [flags] +``` + +Example: + +```bash +gaiad query liquid total-liquid-staked +``` + +Example Output: + +```bash +tokens: "200000000" +``` + +##### total-tokenize-share-assets + +The `total-tokenize-share-assets` command allows users to query the total amount of tokenized assets. + +Usage: + +```bash +gaiad query liquid total-tokenize-share-assets [flags] +``` + +Example: + +```bash +gaiad query liquid total-tokenize-share-assets +``` + +Example Output: + +```bash +value: + amount: "200000000" + denom: uatom +``` + +#### Transactions + +The `tx` commands allows users to interact with the `liquid` module. + +```bash +gaiad tx liquid --help +``` + +##### disable-tokenize-shares + +The command `disable-tokenize-shares` allows users to disable tokenization for their account. + +Usage: + +```bash +gaiad tx liquid disable-tokenize-shares [flags] +``` + +Example: + +```bash +gaiad tx liquid disable-tokenize-shares --from=mykey +``` + +##### enable-tokenize-shares + +The command `enable-tokenize-shares` allows users to enable tokenization for their account. + +Usage: + +```bash +gaiad tx liquid enable-tokenize-shares [flags] +``` + +Example: + +```bash +gaiad tx liquid enable-tokenize-shares --from=mykey +``` + +##### redeem-tokens + +The command `redeem-tokens` allows users to convert a specified amount of tokenized shares for the underlying +delegation. + +Usage: + +```bash +gaiad tx liquid redeem-tokens [amount] [flags] +``` + +Example: + +```bash +gaiad tx liquid redeem-tokens 10000cosmosvaloper1vuvl27z833dksv89vz2205mrwhadez3k3egzrh/1 +``` + +##### tokenize-share + +The command `tokenize-share` allows users to convert a delegation into tokenized shares. + +Usage: + +```bash +gaiad tx liquid tokenize-share [validator-addr] [amount] [rewardOwner] [flags] +``` + +Example: + +```bash +gaiad tx liquid tokenize-share cosmosvaloper1vuvl27z833dksv89vz2205mrwhadez3k3egzrh 1000uatom cosmos15ty20clrlwmph2v8k7qzr4lklpz883zdd89ckp +``` + +##### transfer-tokenize-share-record + +The command `transfer-tokenize-share-record` allows users to transfer a tokenize share record to another owner. + +Usage: + +```bash +gaiad tx liquid transfer-tokenize-share-record [record-id] [new-owner] [flags] +``` + +Example: + +```bash +gaiad tx liquid transfer-tokenize-share-record 1 cosmos15ty20clrlwmph2v8k7qzr4lklpz883zdd89ckp +``` + +##### withdraw-all-tokenize-share-rewards + +The command `withdraw-all-tokenize-share-rewards` allows users to withdraw all rewards for their tokenized shares. + +Usage: + +```bash +gaiad tx liquid withdraw-all-tokenize-share-rewards [flags] +``` + +Example: + +```bash +gaiad tx liquid withdraw-all-tokenize-share-rewards --from=myKey +``` + +##### withdraw-tokenize-share-rewards + +The command `withdraw-tokenize-share-rewards` allows users to withdraw rewards for a tokenize share record. + +Usage: + +```bash +gaiad tx liquid withdraw-tokenize-share-rewards [record-id] [flags] +``` + +Example: + +```bash +gaiad tx liquid withdraw-all-tokenize-share-rewards 1 --from=myKey +``` + +### gRPC + +A user can query the `liquid` module using gRPC endpoints. + +#### LiquidValidator + +The `LiquidValidator` endpoint queries for a single validator's liquid shares. + +```bash +gaia.liquid.v1beta1.Query/LiquidValidator +``` + +Example: + +```bash +grpcurl -plaintext -d '{"validator_addr": "cosmosvaloper12xw6ylce2enratz3m942xd9jnjc4qrkk0yqnmr"}' \ +localhost:9090 gaia.liquid.v1beta1.Query/LiquidValidator +``` + +Example Output: + +```bash +{ + "liquidValidator": { + "operatorAddress": "cosmosvaloper12xw6ylce2enratz3m942xd9jnjc4qrkk0yqnmr", + "liquidShares": "20000" + } +} +``` + +#### AllTokenizeShareRecords + +The `AllTokenizeShareRecords` endpoint queries all tokenize share records. + +```bash +gaia.liquid.v1beta1.Query/AllTokenizeShareRecords +``` + +Example: + +```bash +grpcurl -plaintext localhost:9090 gaia.liquid.v1beta1.Query/AllTokenizeShareRecords +``` + +Example Output: + +```bash +{ + "records": [ + { + "id": "1", + "owner": "cosmos12xw6ylce2enratz3m942xd9jnjc4qrkk0yqnmr", + "moduleAccount": "tokenizeshare_1", + "validator": "cosmosvaloper1jd9slc386vepwpamrrgzkpflhfy94mhqcf0sre" + } + ], + "pagination": { + "total": "1" + } +} +``` + +#### LastTokenizeShareRecordId + +The `LastTokenizeShareRecordId` endpoint queries the last tokenize share record ID issued. + +```bash +gaia.liquid.v1beta1.Query/LastTokenizeShareRecordId +``` + +Example: + +```bash +grpcurl -plaintext localhost:9090 gaia.liquid.v1beta1.Query/LastTokenizeShareRecordId +``` + +Example Output: + +```bash +{ + "id": "1" +} +``` + +#### TokenizeShareLockInfo + +The `TokenizeShareLockInfo` endpoint queries the current tokenization lock status for a given account. + +```bash +gaia.liquid.v1beta1.Query/TokenizeShareLockInfo +``` + +Example: + +```bash +grpcurl -plaintext -d '{"address": "cosmos12xw6ylce2enratz3m942xd9jnjc4qrkk0yqnmr"}' \ +localhost:9090 gaia.liquid.v1beta1.Query/TokenizeShareLockInfo +``` + +Example Output: + +```bash +{ + "status": "TOKENIZE_SHARE_LOCK_STATUS_UNLOCKED" +} +``` + +#### TokenizeShareRecordByDenom + +The `TokenizeShareRecordByDenom` endpoint queries the tokenize share record information for the provided denom. + +```bash +gaia.liquid.v1beta1.Query/TokenizeShareRecordByDenom +``` + +Example: + +```bash +grpcurl -plaintext -d '{"denom": "cosmosvaloper1jd9slc386vepwpamrrgzkpflhfy94mhqcf0sre/1"}' \ +localhost:9090 gaia.liquid.v1beta1.Query/TokenizeShareRecordByDenom +``` + +Example Output: + +```bash +{ + "record": { + "id": "1", + "owner": "cosmos12xw6ylce2enratz3m942xd9jnjc4qrkk0yqnmr", + "moduleAccount": "tokenizeshare_1", + "validator": "cosmosvaloper1jd9slc386vepwpamrrgzkpflhfy94mhqcf0sre" + } +} +``` + +#### TokenizeShareRecordById + +The `TokenizeShareRecordById` endpoint queries the tokenize share record information for the provided record ID. + +```bash +gaia.liquid.v1beta1.Query/TokenizeShareRecordById +``` + +Example: + +```bash +grpcurl -plaintext -d '{"id": "1"}' \ +localhost:9090 gaia.liquid.v1beta1.Query/TokenizeShareRecordById +``` + +Example Output: + +```bash +{ + "record": { + "id": "1", + "owner": "cosmos12xw6ylce2enratz3m942xd9jnjc4qrkk0yqnmr", + "moduleAccount": "tokenizeshare_1", + "validator": "cosmosvaloper1jd9slc386vepwpamrrgzkpflhfy94mhqcf0sre" + } +} +``` + +#### TokenizeShareRecordReward + +The `TokenizeShareRecordReward` endpoint queries the rewards for the provided record owner. + +```bash +gaia.liquid.v1beta1.Query/TokenizeShareRecordReward +``` + +Example: + +```bash +grpcurl -plaintext -d '{"owner_address": "cosmos12xw6ylce2enratz3m942xd9jnjc4qrkk0yqnmr"}' \ +localhost:9090 gaia.liquid.v1beta1.Query/TokenizeShareRecordReward +``` + +Example Output: + +```bash +{ + "rewards": [ + { + "recordId": "1", + "reward": [ + { + "denom": "stake", + "amount": "8588380036928696253000000000" + }, + { + "denom": "uatom", + "amount": "2155511221800000000" + } + ] + } + ], + "total": [ + { + "denom": "stake", + "amount": "8588380036928696253000000000" + }, + { + "denom": "uatom", + "amount": "2155511221800000000" + } + ] +} +``` + +#### TokenizeShareRecordsOwned + +The `TokenizeShareRecordsOwned` command allows users to query the records account address. + +```bash +gaia.liquid.v1beta1.Query/TokenizeShareRecordsOwned +``` + +Example: + +```bash +grpcurl -plaintext -d '{"owner": "cosmos12xw6ylce2enratz3m942xd9jnjc4qrkk0yqnmr"}' \ +localhost:9090 gaia.liquid.v1beta1.Query/TokenizeShareRecordsOwned +``` + +Example Output: + +```bash +{ + "records": [ + { + "id": "1", + "owner": "cosmos12xw6ylce2enratz3m942xd9jnjc4qrkk0yqnmr", + "moduleAccount": "tokenizeshare_1", + "validator": "cosmosvaloper1jd9slc386vepwpamrrgzkpflhfy94mhqcf0sre" + } + ] +} +``` + +#### TotalLiquidStaked + +The `TotalLiquidStaked` endpoint queries the total amount of tokens liquid staked. + +```bash +gaia.liquid.v1beta1.Query/TotalLiquidStaked +``` + +Example: + +```bash +grpcurl -plaintext localhost:9090 gaia.liquid.v1beta1.Query/TotalLiquidStaked +``` + +Example Output: + +```bash +{ + "tokens": "200000000" +} +``` + +#### TotalTokenizeSharedAssets + +The `TotalTokenizeSharedAssets` endpoint queries the total amount of tokenized assets. + +```bash +gaia.liquid.v1beta1.Query/TotalTokenizeSharedAssets +``` + +Example: + +```bash +grpcurl -plaintext localhost:9090 gaia.liquid.v1beta1.Query/TotalTokenizeSharedAssets +``` + +Example Output: + +```bash +{ + "value": { + "denom": "uatom", + "amount": "200000000" + } +} +``` + +#### Params + +The `Params` endpoint queries the module Params. + +```bash +gaia.liquid.v1beta1.Query/Params +``` + +Example: + +```bash +grpcurl -plaintext localhost:9090 gaia.liquid.v1beta1.Query/Params +``` + +Example Output: + +```bash +{ + "params": { + "globalLiquidStakingCap": "250000000000000000", + "validatorLiquidStakingCap": "500000000000000000" + } +} +``` + +### REST + +A user can query the `liquid` module using REST endpoints. + +#### AllTokenizeShareRecords + +The `AllTokenizeShareRecords` REST endpoint queries all tokenize share records. + +```bash +/gaia/liquid/v1beta1/tokenize_share_records +``` + +Example: + +```bash +curl -X GET "http://localhost:1317/gaia/liquid/v1beta1/tokenize_share_records" -H "accept: application/json" +``` + +Example Output: + +```bash +{ + "delegation_responses": [ + { + "delegation": { + "delegator_address": "cosmos1vcs68xf2tnqes5tg0khr0vyevm40ff6zdxatp5", + "validator_address": "cosmosvaloper1quqxfrxkycr0uzt4yk0d57tcq3zk7srm7sm6r8", + "shares": "256250000.000000000000000000" + }, + "balance": { + "denom": "stake", + "amount": "256250000" + } + }, + { + "delegation": { + "delegator_address": "cosmos1vcs68xf2tnqes5tg0khr0vyevm40ff6zdxatp5", + "validator_address": "cosmosvaloper194v8uwee2fvs2s8fa5k7j03ktwc87h5ym39jfv", + "shares": "255150000.000000000000000000" + }, + "balance": { + "denom": "stake", + "amount": "255150000" + } + } + ], + "pagination": { + "next_key": null, + "total": "2" + } +} +``` + +#### LastTokenizeShareRecordId + +The `LastTokenizeShareRecordId` REST endpoint queries the last tokenize share record ID issued. + +```bash +/gaia/liquid/v1beta1/last_tokenize_share_record_id +``` + +Example: + +```bash +curl -X GET "http://localhost:1317/gaia/liquid/v1beta1/last_tokenize_share_record_id" -H "accept: application/json" +``` + +Example Output: + +```bash +{ + "id": "1" +} +``` + +#### TokenizeShareLockInfo + +The `TokenizeShareLockInfo` REST endpoint queries the current tokenization lock status for a given account. + +```bash +/gaia/liquid/v1beta1/tokenize_share_lock_info/{address} +``` + +Example: + +```bash +curl -X GET "http://localhost:1317/gaia/liquid/v1beta1/tokenize_share_lock_info/cosmos12xw6ylce2enratz3m942xd9jnjc4qrkk0yqnmr" -H "accept: application/json" +``` + +Example Output: + +```bash +{ + "status": "TOKENIZE_SHARE_LOCK_STATUS_UNLOCKED", + "expiration_time": "" +} +``` + +#### TokenizeShareRecordById + +The `TokenizeShareRecordById` REST endpoint queries the tokenize share record information for the provided record ID. + +```bash +/gaia/liquid/v1beta1/tokenize_share_record_by_id/{id} +``` + +Example: + +```bash +curl -X GET "http://localhost:1317/gaia/liquid/v1beta1/tokenize_share_record_by_id/1" -H "accept: application/json" +``` + +Example Output: + +```bash +{ + "record": { + "id": "1", + "owner": "cosmos12xw6ylce2enratz3m942xd9jnjc4qrkk0yqnmr", + "module_account": "tokenizeshare_1", + "validator": "cosmosvaloper1jd9slc386vepwpamrrgzkpflhfy94mhqcf0sre" + } +} +``` + +#### TokenizeShareRecordReward + +The `TokenizeShareRecordReward` REST endpoint queries the rewards for the provided record owner. + +```bash +/gaia/liquid/v1beta1/{owner_address}/tokenize_share_record_rewards +``` + +Example: + +```bash +curl -X GET "http://localhost:1317/gaia/liquid/v1beta1/cosmos12xw6ylce2enratz3m942xd9jnjc4qrkk0yqnmr/tokenize_share_record_rewards" -H "accept: application/json" +``` + +Example Output: + +```bash +{ + "rewards": [ + { + "record_id": "1", + "reward": [ + { + "denom": "stake", + "amount": "392793740917.315504955400000000" + }, + { + "denom": "uatom", + "amount": "2.155511221800000000" + } + ] + } + ], + "total": [ + { + "denom": "stake", + "amount": "392793740917.315504955400000000" + }, + { + "denom": "uatom", + "amount": "2.155511221800000000" + } + ] +} +``` + + +#### TokenizeShareRecordsOwned + +The `TokenizeShareRecordsOwned` REST endpoint queries the records account address. + +```bash +/gaia/liquid/v1beta1/tokenize_share_record_owned/{owner} +``` + +Example: + +```bash +curl -X GET "http://localhost:1317/gaia/liquid/v1beta1/tokenize_share_record_owned/cosmos12xw6ylce2enratz3m942xd9jnjc4qrkk0yqnmr" -H "accept: application/json" +``` + +Example Output: + +```bash +{ + "records": [ + { + "id": "1", + "owner": "cosmos12xw6ylce2enratz3m942xd9jnjc4qrkk0yqnmr", + "module_account": "tokenizeshare_1", + "validator": "cosmosvaloper1jd9slc386vepwpamrrgzkpflhfy94mhqcf0sre" + } + ] +} +``` + + +#### TotalLiquidStaked + +The `TotalLiquidStaked` REST endpoint queries the total amount of tokens liquid staked. + +```bash +/gaia/liquid/v1beta1/total_liquid_staked +``` + +Example: + +```bash +curl -X GET "http://localhost:1317/gaia/liquid/v1beta1/total_liquid_staked" -H "accept: application/json" +``` + +Example Output: + +```bash +{ + "tokens": "200000000" +} +``` + +#### TotalTokenizeSharedAssets + +The `TotalTokenizeSharedAssets` REST endpoint queries the total amount of tokenized assets. + +```bash +/gaia/liquid/v1beta1/total_tokenize_shared_assets +``` + +Example: + +```bash +curl -X GET "http://localhost:1317/gaia/liquid/v1beta1/total_tokenize_shared_assets" -H "accept: application/json" +``` + +Example Output: + +```bash +{ + "value": { + "denom": "uatom", + "amount": "200000000" + } +} +``` + +#### Params + +The `Params` REST endpoint queries the module Params. + +```bash +/gaia/liquid/v1beta1/params +``` + +Example: + +```bash +curl -X GET "http://localhost:1317/gaia/liquid/v1beta1/params" -H "accept: application/json" +``` + +Example Output: + +```bash +{ + "params": { + "global_liquid_staking_cap": "0.250000000000000000", + "validator_liquid_staking_cap": "0.500000000000000000" + } +} +``` \ No newline at end of file diff --git a/x/liquid/autocli.go b/x/liquid/autocli.go new file mode 100644 index 00000000..43c05f5e --- /dev/null +++ b/x/liquid/autocli.go @@ -0,0 +1,117 @@ +package liquid + +import ( + "fmt" + + autocliv1 "cosmossdk.io/api/cosmos/autocli/v1" + + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/version" + + "github.com/KYVENetwork/chain/x/liquid/types" +) + +func (am AppModule) AutoCLIOptions() *autocliv1.ModuleOptions { + return &autocliv1.ModuleOptions{ + Query: &autocliv1.ServiceCommandDescriptor{ + Service: types.Query_serviceDesc.ServiceName, + RpcCommandOptions: []*autocliv1.RpcCommandOptions{ + { + RpcMethod: "LiquidValidators", + Use: "liquid-validators", + Short: "Query for all liquid validators", + Example: fmt.Sprintf("$ %s query liquid liquid-validators", version.AppName), + }, + { + RpcMethod: "LiquidValidator", + Use: "liquid-validator [validator-address]", + Short: "Query individual liquid validator by validator address", + Example: fmt.Sprintf( + "$ %s query liquid liquid-validator %s1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj", + version.AppName, sdk.GetConfig().GetBech32ValidatorAddrPrefix()), + PositionalArgs: []*autocliv1.PositionalArgDescriptor{ + {ProtoField: "validator_addr"}, + }, + }, + { + RpcMethod: "TokenizeShareRecordById", + Use: "tokenize-share-record-by-id [id]", + Short: "Query individual tokenize share record information by share by id", + Example: fmt.Sprintf("$ %s query liquid tokenize-share-record-by-id [id]", version.AppName), + PositionalArgs: []*autocliv1.PositionalArgDescriptor{ + {ProtoField: "id"}, + }, + }, + { + RpcMethod: "TokenizeShareRecordByDenom", + Use: "tokenize-share-record-by-denom [denom]", + Short: "Query individual tokenize share record information by share denom", + Example: fmt.Sprintf("$ %s query liquid tokenize-share-record-by-denom [denom]", version.AppName), + PositionalArgs: []*autocliv1.PositionalArgDescriptor{ + {ProtoField: "denom"}, + }, + }, + { + RpcMethod: "TokenizeShareRecordsOwned", + Use: "tokenize-share-records-owned [owner]", + Short: "Query tokenize share records by address", + Example: fmt.Sprintf("$ %s query liquid tokenize-share-records-owned [owner]", version.AppName), + PositionalArgs: []*autocliv1.PositionalArgDescriptor{ + {ProtoField: "owner"}, + }, + }, + { + RpcMethod: "AllTokenizeShareRecords", + Use: "all-tokenize-share-records", + Short: "Query for all tokenize share records", + Example: fmt.Sprintf("$ %s query liquid all-tokenize-share-records", version.AppName), + }, + { + RpcMethod: "LastTokenizeShareRecordId", + Use: "last-tokenize-share-record-id", + Short: "Query for last tokenize share record id", + Example: fmt.Sprintf("$ %s query liquid last-tokenize-share-record-id", version.AppName), + }, + { + RpcMethod: "TotalTokenizeSharedAssets", + Use: "total-tokenize-share-assets", + Short: "Query for total tokenized staked assets", + Example: fmt.Sprintf("$ %s query liquid total-tokenize-share-assets", version.AppName), + }, + { + RpcMethod: "TotalLiquidStaked", + Use: "total-liquid-staked", + Short: "Query for total liquid staked tokens", + Example: fmt.Sprintf("$ %s query liquid total-liquid-staked", version.AppName), + }, + { + RpcMethod: "TokenizeShareLockInfo", + Use: "tokenize-share-lock-info [address]", + Short: "Query tokenize share lock information", + Long: "Query the status of a tokenize share lock for a given account", + Example: fmt.Sprintf( + "$ %s query liquid tokenize-share-lock-info %s1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj", + version.AppName, sdk.GetConfig().GetBech32AccountAddrPrefix()), + PositionalArgs: []*autocliv1.PositionalArgDescriptor{ + {ProtoField: "address"}, + }, + }, + { + RpcMethod: "TokenizeShareRecordReward", + Use: "tokenize-share-record-rewards [owner]", + Short: "Query liquid tokenize share record rewards", + Example: fmt.Sprintf(`$ %s query liquid tokenize-share-record-rewards %s1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj`, + version.AppName, sdk.GetConfig().GetBech32AccountAddrPrefix()), + PositionalArgs: []*autocliv1.PositionalArgDescriptor{ + {ProtoField: "owner_address"}, + }, + }, + }, + }, + Tx: &autocliv1.ServiceCommandDescriptor{ + Service: types.Msg_serviceDesc.ServiceName, + RpcCommandOptions: []*autocliv1.RpcCommandOptions{}, + EnhanceCustomCommand: false, // use custom commands only until v0.51 + }, + } +} diff --git a/x/liquid/client/cli/tx.go b/x/liquid/client/cli/tx.go new file mode 100644 index 00000000..c1040fcc --- /dev/null +++ b/x/liquid/client/cli/tx.go @@ -0,0 +1,338 @@ +package cli + +import ( + "fmt" + "strconv" + "strings" + + "github.com/spf13/cobra" + + "cosmossdk.io/core/address" + + "github.com/cosmos/cosmos-sdk/client" + "github.com/cosmos/cosmos-sdk/client/flags" + "github.com/cosmos/cosmos-sdk/client/tx" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/version" + + "github.com/KYVENetwork/chain/x/liquid/types" +) + +// NewTxCmd returns a root CLI command handler for all x/liquid transaction commands. +func NewTxCmd(valAddrCodec, ac address.Codec) *cobra.Command { + liquidTxCmd := &cobra.Command{ + Use: types.ModuleName, + Short: "Liquid transaction subcommands", + DisableFlagParsing: true, + SuggestionsMinimumDistance: 2, + RunE: client.ValidateCmd, + } + + liquidTxCmd.AddCommand( + NewTokenizeSharesCmd(valAddrCodec, ac), + NewRedeemTokensCmd(), + NewTransferTokenizeShareRecordCmd(ac), + NewDisableTokenizeShares(), + NewEnableTokenizeShares(), + NewWithdrawTokenizeShareRecordRewardCmd(ac), + NewWithdrawAllTokenizeShareRecordRewardCmd(ac), + ) + + return liquidTxCmd +} + +// NewTokenizeSharesCmd defines a command for tokenizing shares from a validator. +func NewTokenizeSharesCmd(valAddrCodec, ac address.Codec) *cobra.Command { + bech32PrefixValAddr := sdk.GetConfig().GetBech32ValidatorAddrPrefix() + bech32PrefixAccAddr := sdk.GetConfig().GetBech32AccountAddrPrefix() + + cmd := &cobra.Command{ + Use: "tokenize-share [validator-addr] [amount] [rewardOwner]", + Short: "Tokenize delegation to share tokens", + Args: cobra.ExactArgs(3), + Long: strings.TrimSpace( + fmt.Sprintf(`Tokenize delegation to share tokens. + +Example: +$ %s tx liquid tokenize-share %s1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj 100stake %s1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj --from mykey +`, + version.AppName, bech32PrefixValAddr, bech32PrefixAccAddr, + ), + ), + RunE: func(cmd *cobra.Command, args []string) error { + clientCtx, err := client.GetClientTxContext(cmd) + if err != nil { + return err + } + + delAddr, err := ac.BytesToString(clientCtx.GetFromAddress()) + if err != nil { + return err + } + + valAddr := args[0] + if _, err = valAddrCodec.StringToBytes(valAddr); err != nil { + return err + } + + amount, err := sdk.ParseCoinNormalized(args[1]) + if err != nil { + return err + } + + _, err = ac.StringToBytes(args[2]) + if err != nil { + return err + } + + msg := &types.MsgTokenizeShares{ + DelegatorAddress: delAddr, + ValidatorAddress: valAddr, + Amount: amount, + TokenizedShareOwner: args[2], + } + + return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg) + }, + } + + flags.AddTxFlagsToCmd(cmd) + + return cmd +} + +// NewRedeemTokensCmd defines a command for redeeming tokens from a validator for shares. +func NewRedeemTokensCmd() *cobra.Command { + cmd := &cobra.Command{ + Use: "redeem-tokens [amount]", + Short: "Redeem specified amount of share tokens to delegation", + Args: cobra.ExactArgs(1), + Long: strings.TrimSpace( + fmt.Sprintf(`Redeem specified amount of share tokens to delegation. + +Example: +$ %s tx liquid redeem-tokens 100sharetoken --from mykey +`, + version.AppName, + ), + ), + RunE: func(cmd *cobra.Command, args []string) error { + clientCtx, err := client.GetClientTxContext(cmd) + if err != nil { + return err + } + delAddr := clientCtx.GetFromAddress() + + amount, err := sdk.ParseCoinNormalized(args[0]) + if err != nil { + return err + } + + msg := &types.MsgRedeemTokensForShares{ + DelegatorAddress: delAddr.String(), + Amount: amount, + } + + return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg) + }, + } + + flags.AddTxFlagsToCmd(cmd) + + return cmd +} + +// NewTransferTokenizeShareRecordCmd defines a command to transfer ownership of TokenizeShareRecord +func NewTransferTokenizeShareRecordCmd(ac address.Codec) *cobra.Command { + bech32PrefixAccAddr := sdk.GetConfig().GetBech32AccountAddrPrefix() + + cmd := &cobra.Command{ + Use: "transfer-tokenize-share-record [record-id] [new-owner]", + Short: "Transfer ownership of TokenizeShareRecord", + Args: cobra.ExactArgs(2), + Long: strings.TrimSpace( + fmt.Sprintf(`Transfer ownership of TokenizeShareRecord. + +Example: +$ %s tx liquid transfer-tokenize-share-record 1 %s1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj --from mykey +`, + version.AppName, bech32PrefixAccAddr, + ), + ), + RunE: func(cmd *cobra.Command, args []string) error { + clientCtx, err := client.GetClientTxContext(cmd) + if err != nil { + return err + } + + recordID, err := strconv.ParseUint(args[0], 10, 64) + if err != nil { + return err + } + + ownerAddr := args[1] + _, err = ac.StringToBytes(ownerAddr) + if err != nil { + return err + } + + msg := &types.MsgTransferTokenizeShareRecord{ + Sender: clientCtx.GetFromAddress().String(), + TokenizeShareRecordId: recordID, + NewOwner: ownerAddr, + } + + return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg) + }, + } + + flags.AddTxFlagsToCmd(cmd) + + return cmd +} + +// NewDisableTokenizeShares defines a command to disable tokenization for an address +func NewDisableTokenizeShares() *cobra.Command { + cmd := &cobra.Command{ + Use: "disable-tokenize-shares", + Short: "Disable tokenization of shares", + Args: cobra.ExactArgs(0), + Long: strings.TrimSpace( + fmt.Sprintf(`Disables the tokenization of shares for an address. The account +must explicitly re-enable if they wish to tokenize again, at which point they must wait +the chain's unbonding period. + +Example: +$ %s tx liquid disable-tokenize-shares --from mykey +`, version.AppName), + ), + RunE: func(cmd *cobra.Command, args []string) error { + clientCtx, err := client.GetClientTxContext(cmd) + if err != nil { + return err + } + + msg := &types.MsgDisableTokenizeShares{ + DelegatorAddress: clientCtx.GetFromAddress().String(), + } + + return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg) + }, + } + + flags.AddTxFlagsToCmd(cmd) + + return cmd +} + +// NewEnableTokenizeShares defines a command to re-enable tokenization for an address +func NewEnableTokenizeShares() *cobra.Command { + cmd := &cobra.Command{ + Use: "enable-tokenize-shares", + Short: "Enable tokenization of shares", + Args: cobra.ExactArgs(0), + Long: strings.TrimSpace( + fmt.Sprintf(`Enables the tokenization of shares for an address after +it had been disable. This transaction queues the enablement of tokenization, but +the address must wait 1 unbonding period from the time of this transaction before +tokenization is permitted. + +Example: +$ %s tx liquid enable-tokenize-shares --from mykey +`, version.AppName), + ), + RunE: func(cmd *cobra.Command, args []string) error { + clientCtx, err := client.GetClientTxContext(cmd) + if err != nil { + return err + } + + msg := &types.MsgEnableTokenizeShares{ + DelegatorAddress: clientCtx.GetFromAddress().String(), + } + + return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg) + }, + } + + flags.AddTxFlagsToCmd(cmd) + + return cmd +} + +// WithdrawAllTokenizeShareRecordReward defines a method to withdraw reward for all owning TokenizeShareRecord +func NewWithdrawAllTokenizeShareRecordRewardCmd(ac address.Codec) *cobra.Command { + cmd := &cobra.Command{ + Use: "withdraw-all-tokenize-share-rewards", + Args: cobra.ExactArgs(0), + Short: "Withdraw reward for all owning TokenizeShareRecord", + Long: strings.TrimSpace( + fmt.Sprintf(`Withdraw reward for all owned TokenizeShareRecord +Example: +$ %s tx distribution withdraw-all-tokenize-share-rewards --from mykey +`, + version.AppName, + ), + ), + RunE: func(cmd *cobra.Command, args []string) error { + clientCtx, err := client.GetClientTxContext(cmd) + if err != nil { + return err + } + + ownerAddr, err := ac.BytesToString(clientCtx.GetFromAddress()) + if err != nil { + return err + } + + msg := types.NewMsgWithdrawAllTokenizeShareRecordReward(ownerAddr) + + return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg) + }, + } + + flags.AddTxFlagsToCmd(cmd) + + return cmd +} + +// WithdrawTokenizeShareRecordReward defines a method to withdraw reward for an owning TokenizeShareRecord +func NewWithdrawTokenizeShareRecordRewardCmd(ac address.Codec) *cobra.Command { + cmd := &cobra.Command{ + Use: "withdraw-tokenize-share-rewards [record-id]", + Args: cobra.ExactArgs(1), + Short: "Withdraw reward for an owning TokenizeShareRecord", + Long: strings.TrimSpace( + fmt.Sprintf(`Withdraw reward for an owned TokenizeShareRecord +Example: +$ %s tx distribution withdraw-tokenize-share-rewards 1 --from mykey +`, + version.AppName, + ), + ), + RunE: func(cmd *cobra.Command, args []string) error { + clientCtx, err := client.GetClientTxContext(cmd) + if err != nil { + return err + } + + ownerAddr, err := ac.BytesToString(clientCtx.GetFromAddress()) + if err != nil { + return err + } + + recordID, err := strconv.ParseUint(args[0], 10, 64) + if err != nil { + return err + } + + msg := types.NewMsgWithdrawTokenizeShareRecordReward(ownerAddr, recordID) + + return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg) + }, + } + + flags.AddTxFlagsToCmd(cmd) + + return cmd +} diff --git a/x/liquid/keeper/abci.go b/x/liquid/keeper/abci.go new file mode 100644 index 00000000..6f8187cf --- /dev/null +++ b/x/liquid/keeper/abci.go @@ -0,0 +1,14 @@ +package keeper + +import ( + "context" + + sdk "github.com/cosmos/cosmos-sdk/types" +) + +// BeginBlocker removes expired tokenize share locks +func (k *Keeper) BeginBlocker(ctx context.Context) error { + sdkCtx := sdk.UnwrapSDKContext(ctx) + _, err := k.RemoveExpiredTokenizeShareLocks(ctx, sdkCtx.BlockTime()) + return err +} diff --git a/x/liquid/keeper/distribution.go b/x/liquid/keeper/distribution.go new file mode 100644 index 00000000..d9c2505d --- /dev/null +++ b/x/liquid/keeper/distribution.go @@ -0,0 +1,215 @@ +package keeper + +import ( + "context" + goerrors "errors" + + errorsmod "cosmossdk.io/errors" + + sdk "github.com/cosmos/cosmos-sdk/types" + sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" + + "github.com/KYVENetwork/chain/x/liquid/types" +) + +func (k Keeper) WithdrawSingleShareRecordReward(ctx context.Context, recordID uint64) error { + record, err := k.GetTokenizeShareRecord(ctx, recordID) + if err != nil { + return err + } + + ownerAddr, err := k.authKeeper.AddressCodec().StringToBytes(record.Owner) + if err != nil { + return err + } + owner := sdk.AccAddress(ownerAddr) + + // This check is necessary to prevent sending rewards to a blacklisted address + if k.bankKeeper.BlockedAddr(owner) { + return errorsmod.Wrapf(sdkerrors.ErrUnauthorized, "%s is not allowed to receive funds", owner.String()) + } + + valAddr, err := k.stakingKeeper.ValidatorAddressCodec().StringToBytes(record.Validator) + if err != nil { + return err + } + + validatorFound := true + _, err = k.stakingKeeper.Validator(ctx, valAddr) + if err != nil { + if !goerrors.Is(err, stakingtypes.ErrNoValidatorFound) { + return err + } + + validatorFound = false + } + + delegationFound := true + _, err = k.stakingKeeper.Delegation(ctx, record.GetModuleAddress(), valAddr) + if err != nil { + if !goerrors.Is(err, stakingtypes.ErrNoDelegation) { + return err + } + + delegationFound = false + } + + sdkCtx := sdk.UnwrapSDKContext(ctx) + if validatorFound && delegationFound { + // withdraw rewards into reward module account and send it to reward owner + cacheCtx, write := sdkCtx.CacheContext() + _, err = k.distKeeper.WithdrawDelegationRewards(cacheCtx, record.GetModuleAddress(), valAddr) + if err != nil { + return err + } + write() + } + + // apply changes when the module account has positive balance + balances := k.bankKeeper.GetAllBalances(ctx, record.GetModuleAddress()) + if !balances.Empty() { + err = k.bankKeeper.SendCoins(ctx, record.GetModuleAddress(), owner, balances) + if err != nil { + return err + } + + sdkCtx.EventManager().EmitEvent( + sdk.NewEvent( + types.EventTypeWithdrawTokenizeShareReward, + sdk.NewAttribute(types.AttributeKeyWithdrawAddress, owner.String()), + sdk.NewAttribute(sdk.AttributeKeyAmount, balances.String()), + ), + ) + } + return nil +} + +// WithdrawTokenizeShareRecordReward withdraws rewards for owning a TokenizeShareRecord +func (k Keeper) WithdrawTokenizeShareRecordReward(ctx context.Context, ownerAddr sdk.AccAddress, + recordID uint64, +) (sdk.Coins, error) { + record, err := k.GetTokenizeShareRecord(ctx, recordID) + if err != nil { + return nil, err + } + + // This check is necessary to prevent sending rewards to a blacklisted address + if k.bankKeeper.BlockedAddr(ownerAddr) { + return nil, errorsmod.Wrapf(sdkerrors.ErrUnauthorized, "%s is not allowed to receive funds", ownerAddr) + } + + if record.Owner != ownerAddr.String() { + return nil, types.ErrNotTokenizeShareRecordOwner + } + + valAddr, err := k.stakingKeeper.ValidatorAddressCodec().StringToBytes(record.Validator) + if err != nil { + return nil, err + } + + _, err = k.stakingKeeper.Validator(ctx, valAddr) + if err != nil { + return nil, err + } + + _, err = k.stakingKeeper.Delegation(ctx, record.GetModuleAddress(), valAddr) + if err != nil { + return nil, err + } + + // withdraw rewards into reward module account and send it to reward owner + _, err = k.distKeeper.WithdrawDelegationRewards(ctx, record.GetModuleAddress(), valAddr) + if err != nil { + return nil, err + } + + // apply changes when the module account has positive balance + rewards := k.bankKeeper.GetAllBalances(ctx, record.GetModuleAddress()) + if !rewards.Empty() { + err = k.bankKeeper.SendCoins(ctx, record.GetModuleAddress(), ownerAddr, rewards) + if err != nil { + return nil, err + } + } + + sdkCtx := sdk.UnwrapSDKContext(ctx) + sdkCtx.EventManager().EmitEvent( + sdk.NewEvent( + types.EventTypeWithdrawTokenizeShareReward, + sdk.NewAttribute(types.AttributeKeyWithdrawAddress, ownerAddr.String()), + sdk.NewAttribute(sdk.AttributeKeyAmount, rewards.String()), + ), + ) + + return rewards, nil +} + +// withdraw reward for all owning TokenizeShareRecord +func (k Keeper) WithdrawAllTokenizeShareRecordReward(ctx sdk.Context, ownerAddr sdk.AccAddress) (sdk.Coins, error) { + // This check is necessary to prevent sending rewards to a blacklisted address + if k.bankKeeper.BlockedAddr(ownerAddr) { + return nil, errorsmod.Wrapf(sdkerrors.ErrUnauthorized, "%s is not allowed to receive external funds", ownerAddr) + } + + totalRewards := sdk.Coins{} + + records := k.GetTokenizeShareRecordsByOwner(ctx, ownerAddr) + + for _, record := range records { + valAddr, err := k.stakingKeeper.ValidatorAddressCodec().StringToBytes(record.Validator) + if err != nil { + return nil, err + } + + _, err = k.stakingKeeper.Validator(ctx, valAddr) + if err != nil && !goerrors.Is(err, stakingtypes.ErrNoValidatorFound) { + return nil, err + } + + // if the error is ErrNoValidatorFound + if err != nil { + continue + } + + _, err = k.stakingKeeper.Delegation(ctx, record.GetModuleAddress(), valAddr) + if err != nil && !goerrors.Is(err, stakingtypes.ErrNoDelegation) { + return nil, err + } + + // if the error is ErrNoDelegation + if err != nil { + continue + } + + // withdraw rewards into reward module account and send it to reward owner + cacheCtx, write := ctx.CacheContext() + _, err = k.distKeeper.WithdrawDelegationRewards(cacheCtx, record.GetModuleAddress(), valAddr) + if err != nil { + k.Logger(ctx).Error(err.Error()) + continue + } + + // apply changes when the module account has positive balance + balances := k.bankKeeper.GetAllBalances(cacheCtx, record.GetModuleAddress()) + if !balances.Empty() { + err = k.bankKeeper.SendCoins(cacheCtx, record.GetModuleAddress(), ownerAddr, balances) + if err != nil { + k.Logger(ctx).Error(err.Error()) + continue + } + write() + totalRewards = totalRewards.Add(balances...) + } + } + + ctx.EventManager().EmitEvent( + sdk.NewEvent( + types.EventTypeWithdrawTokenizeShareReward, + sdk.NewAttribute(types.AttributeKeyWithdrawAddress, ownerAddr.String()), + sdk.NewAttribute(sdk.AttributeKeyAmount, totalRewards.String()), + ), + ) + + return totalRewards, nil +} diff --git a/x/liquid/keeper/genesis.go b/x/liquid/keeper/genesis.go new file mode 100644 index 00000000..b351d64c --- /dev/null +++ b/x/liquid/keeper/genesis.go @@ -0,0 +1,85 @@ +package keeper + +import ( + "context" + "fmt" + + sdk "github.com/cosmos/cosmos-sdk/types" + + "github.com/KYVENetwork/chain/x/liquid/types" +) + +// InitGenesis sets liquid information for genesis +func (k Keeper) InitGenesis(ctx context.Context, data *types.GenesisState) { + // Set the x/liquid module parameters + if err := k.SetParams(ctx, data.Params); err != nil { + panic(err) + } + + // Set the total liquid staked tokens + k.SetTotalLiquidStakedTokens(ctx, data.TotalLiquidStakedTokens) + + // Set each tokenize share record, as well as the last tokenize share record ID + latestID := uint64(0) + for _, tokenizeShareRecord := range data.TokenizeShareRecords { + if err := k.AddTokenizeShareRecord(ctx, tokenizeShareRecord); err != nil { + panic(err) + } + if tokenizeShareRecord.Id > latestID { + latestID = tokenizeShareRecord.Id + } + } + if data.LastTokenizeShareRecordId < latestID { + panic("Tokenize share record specified with ID greater than the latest ID") + } + k.SetLastTokenizeShareRecordID(ctx, data.LastTokenizeShareRecordId) + + // Set the tokenize shares locks for accounts that have disabled tokenizing shares + // The lock can either be in status LOCKED or LOCK_EXPIRING + // If it is in status LOCK_EXPIRING, the unlocking must also be queued + k.SetTokenizeShareLocks(ctx, data.TokenizeShareLocks) +} + +func (k Keeper) SetTokenizeShareLocks(ctx context.Context, tokenizeShareLocks []types.TokenizeShareLock) { + // Set the tokenize shares locks for accounts that have disabled tokenizing shares + // The lock can either be in status LOCKED or LOCK_EXPIRING + // If it is in status LOCK_EXPIRING, the unlocking must also be queued + for _, tokenizeShareLock := range tokenizeShareLocks { + address, err := k.authKeeper.AddressCodec().StringToBytes(tokenizeShareLock.Address) + if err != nil { + panic(err) + } + + switch tokenizeShareLock.Status { + case types.TOKENIZE_SHARE_LOCK_STATUS_LOCKED.String(): + k.AddTokenizeSharesLock(ctx, address) + + case types.TOKENIZE_SHARE_LOCK_STATUS_LOCK_EXPIRING.String(): + completionTime := tokenizeShareLock.CompletionTime + + authorizations := k.GetPendingTokenizeShareAuthorizations(ctx, completionTime) + authorizations.Addresses = append(authorizations.Addresses, sdk.AccAddress(address).String()) + + k.SetPendingTokenizeShareAuthorizations(ctx, completionTime, authorizations) + k.SetTokenizeSharesUnlockTime(ctx, address, completionTime) + + default: + panic(fmt.Sprintf("Unsupported tokenize share lock status %s", tokenizeShareLock.Status)) + } + } +} + +func (k Keeper) ExportGenesis(ctx context.Context) *types.GenesisState { + params, err := k.GetParams(ctx) + if err != nil { + panic(err) + } + + return &types.GenesisState{ + Params: params, + TokenizeShareRecords: k.GetAllTokenizeShareRecords(ctx), + LastTokenizeShareRecordId: k.GetLastTokenizeShareRecordID(ctx), + TotalLiquidStakedTokens: k.GetTotalLiquidStakedTokens(ctx), + TokenizeShareLocks: k.GetAllTokenizeSharesLocks(ctx), + } +} diff --git a/x/liquid/keeper/grpc_query.go b/x/liquid/keeper/grpc_query.go new file mode 100644 index 00000000..caf18747 --- /dev/null +++ b/x/liquid/keeper/grpc_query.go @@ -0,0 +1,334 @@ +package keeper + +import ( + "context" + goerrors "errors" + + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" + + "cosmossdk.io/math" + "cosmossdk.io/store/prefix" + + "github.com/cosmos/cosmos-sdk/runtime" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/types/query" + stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" + + "github.com/KYVENetwork/chain/x/liquid/types" +) + +// Querier is used as Keeper will have duplicate methods if used directly, and gRPC names take precedence over keeper +type Querier struct { + *Keeper +} + +var _ types.QueryServer = Querier{} + +func NewQuerier(keeper *Keeper) Querier { + return Querier{Keeper: keeper} +} + +// Params queries the staking parameters +func (k Querier) Params(ctx context.Context, _ *types.QueryParamsRequest) (*types.QueryParamsResponse, error) { + params, err := k.GetParams(ctx) + if err != nil { + return nil, err + } + return &types.QueryParamsResponse{Params: params}, nil +} + +// LiquidValidator queries for a LiquidValidator record by validator address +func (k Querier) LiquidValidator(c context.Context, req *types.QueryLiquidValidatorRequest) (*types.QueryLiquidValidatorResponse, error) { + if req == nil { + return nil, status.Error(codes.InvalidArgument, "empty request") + } + ctx := sdk.UnwrapSDKContext(c) + valAddr, err := k.stakingKeeper.ValidatorAddressCodec().StringToBytes(req.ValidatorAddr) + if err != nil { + return nil, err + } + lv, err := k.GetLiquidValidator(ctx, valAddr) + if err != nil { + return nil, err + } + return &types.QueryLiquidValidatorResponse{LiquidValidator: lv}, nil +} + +// LiquidValidators queries for all LiquidValidator records +func (k Querier) LiquidValidators(c context.Context, req *types.QueryLiquidValidatorsRequest) (*types.QueryLiquidValidatorsResponse, error) { + if req == nil { + return nil, status.Error(codes.InvalidArgument, "empty request") + } + + store := runtime.KVStoreAdapter(k.storeService.OpenKVStore(c)) + valStore := prefix.NewStore(store, types.LiquidValidatorPrefix) + + var liquidValidators []types.LiquidValidator + + pageRes, err := query.Paginate(valStore, req.Pagination, func(key, value []byte) error { + var val types.LiquidValidator + if err := k.cdc.Unmarshal(value, &val); err != nil { + return err + } + liquidValidators = append(liquidValidators, val) + return nil + }) + if err != nil { + return nil, status.Error(codes.Internal, err.Error()) + } + + return &types.QueryLiquidValidatorsResponse{ + LiquidValidators: liquidValidators, + Pagination: pageRes, + }, nil +} + +// TokenizeShareRecordById queries for individual tokenize share record information by share by id +func (k Querier) TokenizeShareRecordById(c context.Context, req *types.QueryTokenizeShareRecordByIdRequest) (*types.QueryTokenizeShareRecordByIdResponse, error) { //nolint:revive // fixing this would require changing the .proto files, so we might as well leave it alone + if req == nil { + return nil, status.Error(codes.InvalidArgument, "empty request") + } + + ctx := sdk.UnwrapSDKContext(c) + record, err := k.GetTokenizeShareRecord(ctx, req.Id) + if err != nil { + return nil, err + } + + return &types.QueryTokenizeShareRecordByIdResponse{ + Record: record, + }, nil +} + +// TokenizeShareRecordByDenom queries for individual tokenize share record information by share denom +func (k Querier) TokenizeShareRecordByDenom(c context.Context, req *types.QueryTokenizeShareRecordByDenomRequest) (*types.QueryTokenizeShareRecordByDenomResponse, error) { + if req == nil { + return nil, status.Error(codes.InvalidArgument, "empty request") + } + + ctx := sdk.UnwrapSDKContext(c) + record, err := k.GetTokenizeShareRecordByDenom(ctx, req.Denom) + if err != nil { + return nil, err + } + + return &types.QueryTokenizeShareRecordByDenomResponse{ + Record: record, + }, nil +} + +// TokenizeShareRecordsOwned queries tokenize share records by address +func (k Querier) TokenizeShareRecordsOwned(c context.Context, req *types.QueryTokenizeShareRecordsOwnedRequest) (*types.QueryTokenizeShareRecordsOwnedResponse, error) { + if req == nil { + return nil, status.Error(codes.InvalidArgument, "empty request") + } + + ctx := sdk.UnwrapSDKContext(c) + owner, err := k.authKeeper.AddressCodec().StringToBytes(req.Owner) + if err != nil { + return nil, err + } + records := k.GetTokenizeShareRecordsByOwner(ctx, owner) + + return &types.QueryTokenizeShareRecordsOwnedResponse{ + Records: records, + }, nil +} + +// AllTokenizeShareRecords queries for all tokenize share records +func (k Querier) AllTokenizeShareRecords(c context.Context, req *types.QueryAllTokenizeShareRecordsRequest) (*types.QueryAllTokenizeShareRecordsResponse, error) { + if req == nil { + return nil, status.Error(codes.InvalidArgument, "empty request") + } + ctx := sdk.UnwrapSDKContext(c) + + var records []types.TokenizeShareRecord + + store := k.storeService.OpenKVStore(ctx) + valStore := prefix.NewStore(runtime.KVStoreAdapter(store), types.TokenizeShareRecordPrefix) + pageRes, err := query.FilteredPaginate(valStore, req.Pagination, func(key, value []byte, accumulate bool) (bool, error) { + var tokenizeShareRecord types.TokenizeShareRecord + if err := k.cdc.Unmarshal(value, &tokenizeShareRecord); err != nil { + return false, err + } + + if accumulate { + records = append(records, tokenizeShareRecord) + } + return true, nil + }) + if err != nil { + return nil, status.Error(codes.Internal, err.Error()) + } + + return &types.QueryAllTokenizeShareRecordsResponse{ + Records: records, + Pagination: pageRes, + }, nil +} + +// LastTokenizeShareRecordId queries for last tokenize share record id +func (k Querier) LastTokenizeShareRecordId(c context.Context, req *types.QueryLastTokenizeShareRecordIdRequest) (*types.QueryLastTokenizeShareRecordIdResponse, error) { //nolint:revive // fixing this would require changing the .proto files, so we might as well leave it alone + if req == nil { + return nil, status.Error(codes.InvalidArgument, "empty request") + } + + ctx := sdk.UnwrapSDKContext(c) + return &types.QueryLastTokenizeShareRecordIdResponse{ + Id: k.GetLastTokenizeShareRecordID(ctx), + }, nil +} + +// TotalTokenizeSharedAssets queries for total tokenized staked assets +func (k Querier) TotalTokenizeSharedAssets(c context.Context, req *types.QueryTotalTokenizeSharedAssetsRequest) (*types.QueryTotalTokenizeSharedAssetsResponse, error) { + if req == nil { + return nil, status.Error(codes.InvalidArgument, "empty request") + } + ctx := sdk.UnwrapSDKContext(c) + records := k.GetAllTokenizeShareRecords(ctx) + totalTokenizeShared := math.ZeroInt() + + for _, record := range records { + moduleAcc := record.GetModuleAddress() + valAddr, err := k.stakingKeeper.ValidatorAddressCodec().StringToBytes(record.Validator) + if err != nil { + return nil, err + } + + validator, err := k.stakingKeeper.GetValidator(ctx, valAddr) + if err != nil { + return nil, err + } + + delegation, err := k.stakingKeeper.GetDelegation(ctx, moduleAcc, valAddr) + if err != nil { + return nil, err + } + + tokens := validator.TokensFromShares(delegation.Shares) + totalTokenizeShared = totalTokenizeShared.Add(tokens.RoundInt()) + } + + bondDenom, err := k.stakingKeeper.BondDenom(ctx) + if err != nil { + return nil, err + } + + return &types.QueryTotalTokenizeSharedAssetsResponse{ + Value: sdk.NewCoin(bondDenom, totalTokenizeShared), + }, nil +} + +// TotalLiquidStaked queries for total tokenized staked tokens +// Liquid staked tokens are either tokenized delegations or delegations +// owned by a module account +func (k Querier) TotalLiquidStaked(c context.Context, req *types.QueryTotalLiquidStaked) (*types.QueryTotalLiquidStakedResponse, error) { + if req == nil { + return nil, status.Error(codes.InvalidArgument, "empty request") + } + ctx := sdk.UnwrapSDKContext(c) + totalLiquidStaked := k.GetTotalLiquidStakedTokens(ctx).String() + return &types.QueryTotalLiquidStakedResponse{ + Tokens: totalLiquidStaked, + }, nil +} + +// TokenizeShareLockInfo queries status of an account's tokenize share lock +func (k Querier) TokenizeShareLockInfo(c context.Context, req *types.QueryTokenizeShareLockInfo) (*types.QueryTokenizeShareLockInfoResponse, error) { + if req == nil { + return nil, status.Error(codes.InvalidArgument, "empty request") + } + ctx := sdk.UnwrapSDKContext(c) + + address, err := k.authKeeper.AddressCodec().StringToBytes(req.Address) + if err != nil { + panic(err) + } + + lockStatus, completionTime := k.GetTokenizeSharesLock(ctx, address) + + timeString := "" + if !completionTime.IsZero() { + timeString = completionTime.String() + } + + return &types.QueryTokenizeShareLockInfoResponse{ + Status: lockStatus.String(), + ExpirationTime: timeString, + }, nil +} + +// TokenizeShareRecordReward returns estimated amount of reward from tokenize share record ownership +func (k Keeper) TokenizeShareRecordReward(c context.Context, req *types.QueryTokenizeShareRecordRewardRequest) (*types.QueryTokenizeShareRecordRewardResponse, error) { + ctx := sdk.UnwrapSDKContext(c) + + totalRewards := sdk.DecCoins{} + rewards := []types.TokenizeShareRecordReward{} + + ownerAddr, err := k.authKeeper.AddressCodec().StringToBytes(req.OwnerAddress) + if err != nil { + return nil, err + } + records := k.GetTokenizeShareRecordsByOwner(ctx, ownerAddr) + for _, record := range records { + valAddr, err := k.stakingKeeper.ValidatorAddressCodec().StringToBytes(record.Validator) + if err != nil { + return nil, err + } + + moduleAddr := record.GetModuleAddress() + moduleBalance := k.bankKeeper.GetAllBalances(ctx, moduleAddr) + moduleBalanceDecCoins := sdk.NewDecCoinsFromCoins(moduleBalance...) + + validatorFound := true + val, err := k.stakingKeeper.Validator(ctx, valAddr) + if err != nil { + if !goerrors.Is(err, stakingtypes.ErrNoValidatorFound) { + return nil, err + } + + validatorFound = false + } + + delegationFound := true + del, err := k.stakingKeeper.Delegation(ctx, moduleAddr, valAddr) + if err != nil { + if !goerrors.Is(err, stakingtypes.ErrNoDelegation) { + return nil, err + } + + delegationFound = false + } + + if validatorFound && delegationFound { + // withdraw rewards + endingPeriod, err := k.distKeeper.IncrementValidatorPeriod(ctx, val) + if err != nil { + return nil, err + } + + recordReward, err := k.distKeeper.CalculateDelegationRewards(ctx, val, del, endingPeriod) + if err != nil { + return nil, err + } + + rewards = append(rewards, types.TokenizeShareRecordReward{ + RecordId: record.Id, + Reward: recordReward.Add(moduleBalanceDecCoins...), + }) + totalRewards = totalRewards.Add(recordReward...).Add(moduleBalanceDecCoins...) + } else if !moduleBalance.IsZero() { + rewards = append(rewards, types.TokenizeShareRecordReward{ + RecordId: record.Id, + Reward: moduleBalanceDecCoins, + }) + totalRewards = totalRewards.Add(moduleBalanceDecCoins...) + } + } + + return &types.QueryTokenizeShareRecordRewardResponse{ + Rewards: rewards, + Total: totalRewards, + }, nil +} diff --git a/x/liquid/keeper/grpc_query_test.go b/x/liquid/keeper/grpc_query_test.go new file mode 100644 index 00000000..6473f924 --- /dev/null +++ b/x/liquid/keeper/grpc_query_test.go @@ -0,0 +1,187 @@ +package keeper_test + +import ( + gocontext "context" + "fmt" + + "cosmossdk.io/math" + + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/types/query" + + "github.com/KYVENetwork/chain/x/liquid/types" +) + +func (s *KeeperTestSuite) TestGRPCQueryLiquidValidator() { + ctx, keeper, queryClient := s.ctx, s.lsmKeeper, s.queryClient + require := s.Require() + + lVal := types.NewLiquidValidator(sdk.ValAddress(PKs[0].Address().Bytes()).String()) + lVal.LiquidShares = math.LegacyNewDec(10000) + require.NoError(keeper.SetLiquidValidator(ctx, lVal)) + var req *types.QueryLiquidValidatorRequest + testCases := []struct { + msg string + malleate func() + expPass bool + }{ + { + "empty request", + func() { + req = &types.QueryLiquidValidatorRequest{} + }, + false, + }, + { + "nil request", + func() { + req = nil + }, + false, + }, + { + "with valid and not existing address", + func() { + req = &types.QueryLiquidValidatorRequest{ + ValidatorAddr: "cosmosvaloper15jkng8hytwt22lllv6mw4k89qkqehtahd84ptu", + } + }, + false, + }, + { + "valid request", + func() { + req = &types.QueryLiquidValidatorRequest{ValidatorAddr: lVal.OperatorAddress} + }, + true, + }, + } + + for _, tc := range testCases { + s.Run(fmt.Sprintf("Case %s", tc.msg), func() { + tc.malleate() + res, err := queryClient.LiquidValidator(gocontext.Background(), req) + if tc.expPass { + require.NoError(err) + require.Equal(lVal.OperatorAddress, res.LiquidValidator.OperatorAddress) + require.Equal(lVal.LiquidShares, res.LiquidValidator.LiquidShares) + } else { + require.Error(err) + require.Nil(res) + } + }) + } +} + +func (s *KeeperTestSuite) TestGRPCQueryLiquidValidators() { + ctx, keeper, queryClient := s.ctx, s.lsmKeeper, s.queryClient + require := s.Require() + + // Create multiple liquid validators for testing + lVal1 := types.NewLiquidValidator(sdk.ValAddress(PKs[0].Address().Bytes()).String()) + lVal1.LiquidShares = math.LegacyNewDec(10000) + require.NoError(keeper.SetLiquidValidator(ctx, lVal1)) + + lVal2 := types.NewLiquidValidator(sdk.ValAddress(PKs[1].Address().Bytes()).String()) + lVal2.LiquidShares = math.LegacyNewDec(20000) + require.NoError(keeper.SetLiquidValidator(ctx, lVal2)) + + lVal3 := types.NewLiquidValidator(sdk.ValAddress(PKs[2].Address().Bytes()).String()) + lVal3.LiquidShares = math.LegacyNewDec(30000) + require.NoError(keeper.SetLiquidValidator(ctx, lVal3)) + + var req *types.QueryLiquidValidatorsRequest + testCases := []struct { + msg string + malleate func() + expPass bool + }{ + { + "empty request", + func() { + req = &types.QueryLiquidValidatorsRequest{} + }, + true, + }, + { + "valid request with pagination limit", + func() { + req = &types.QueryLiquidValidatorsRequest{ + Pagination: &query.PageRequest{ + Limit: 2, + }, + } + }, + true, + }, + { + "valid request with offset pagination", + func() { + req = &types.QueryLiquidValidatorsRequest{ + Pagination: &query.PageRequest{ + Offset: 1, + Limit: 2, + }, + } + }, + true, + }, + { + "request with count total", + func() { + req = &types.QueryLiquidValidatorsRequest{ + Pagination: &query.PageRequest{ + CountTotal: true, + }, + } + }, + true, + }, + } + + for _, tc := range testCases { + s.Run(fmt.Sprintf("Case %s", tc.msg), func() { + tc.malleate() + res, err := queryClient.LiquidValidators(gocontext.Background(), req) + if tc.expPass { + require.NoError(err) + require.NotNil(res) + require.NotNil(res.LiquidValidators) + + // Additional checks for specific test cases + if tc.msg == "empty request" { + // Should return all validators + require.Len(res.LiquidValidators, 3) + + // Verify the validators are correct + foundValidators := make(map[string]bool) + for _, lv := range res.LiquidValidators { + foundValidators[lv.OperatorAddress] = true + } + require.True(foundValidators[lVal1.OperatorAddress]) + require.True(foundValidators[lVal2.OperatorAddress]) + require.True(foundValidators[lVal3.OperatorAddress]) + } + + if tc.msg == "request with count total" { + require.NotNil(res.Pagination) + require.Equal(uint64(3), res.Pagination.Total) + require.Len(res.LiquidValidators, 3) + } + + if tc.msg == "valid request with pagination limit" { + require.NotNil(res.Pagination) + require.Len(res.LiquidValidators, 2) + } + + if tc.msg == "valid request with offset pagination" { + require.NotNil(res.Pagination) + require.Len(res.LiquidValidators, 2) + } + } else { + require.Error(err) + require.Nil(res) + } + }) + } +} diff --git a/x/liquid/keeper/hooks.go b/x/liquid/keeper/hooks.go new file mode 100644 index 00000000..31f2bde6 --- /dev/null +++ b/x/liquid/keeper/hooks.go @@ -0,0 +1,97 @@ +package keeper + +import ( + "context" + + sdkmath "cosmossdk.io/math" + + sdk "github.com/cosmos/cosmos-sdk/types" + stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" + + "github.com/KYVENetwork/chain/x/liquid/types" +) + +// Wrapper struct +type Hooks struct { + k Keeper +} + +var _ stakingtypes.StakingHooks = Hooks{} + +// Create new liquid hooks +func (k Keeper) Hooks() Hooks { + return Hooks{k} +} + +// initialize liquid validator record +func (h Hooks) AfterValidatorCreated(ctx context.Context, valAddr sdk.ValAddress) error { + val, err := h.k.stakingKeeper.Validator(ctx, valAddr) + if err != nil { + return err + } + lVal := types.NewLiquidValidator(val.GetOperator()) + return h.k.SetLiquidValidator(ctx, lVal) +} + +func (h Hooks) AfterValidatorRemoved(ctx context.Context, _ sdk.ConsAddress, valAddr sdk.ValAddress) error { + return h.k.RemoveLiquidValidator(ctx, valAddr) +} + +func (h Hooks) BeforeDelegationCreated(_ context.Context, _ sdk.AccAddress, _ sdk.ValAddress) error { + return nil +} + +func (h Hooks) BeforeDelegationSharesModified(_ context.Context, _ sdk.AccAddress, _ sdk.ValAddress) error { + return nil +} + +func (h Hooks) AfterDelegationModified(_ context.Context, _ sdk.AccAddress, _ sdk.ValAddress) error { + return nil +} + +func (h Hooks) BeforeValidatorSlashed(ctx context.Context, valAddr sdk.ValAddress, fraction sdkmath.LegacyDec) error { + // fraction = tokens_to_burn / validator.Tokens + validator, err := h.k.stakingKeeper.Validator(ctx, valAddr) + if err != nil { + return err + } + liquidVal, err := h.k.GetLiquidValidator(ctx, valAddr) + if err != nil { + return err + } + initialLiquidTokens := validator.TokensFromShares(liquidVal.LiquidShares).TruncateInt() + slashedLiquidTokens := fraction.Mul(sdkmath.LegacyNewDecFromInt(initialLiquidTokens)) + + decrease := slashedLiquidTokens.TruncateInt() + if err := h.k.DecreaseTotalLiquidStakedTokens(ctx, decrease); err != nil { + // This only error's if the total liquid staked tokens underflows + // which would indicate there's a corrupted state where the validator has + // liquid tokens that are not accounted for in the global total + panic(err) + } + return nil +} + +func (h Hooks) BeforeValidatorModified(_ context.Context, _ sdk.ValAddress) error { + return nil +} + +func (h Hooks) AfterValidatorBonded(_ context.Context, _ sdk.ConsAddress, _ sdk.ValAddress) error { + return nil +} + +func (h Hooks) AfterValidatorBeginUnbonding(_ context.Context, _ sdk.ConsAddress, _ sdk.ValAddress) error { + return nil +} + +func (h Hooks) BeforeDelegationRemoved(_ context.Context, _ sdk.AccAddress, _ sdk.ValAddress) error { + return nil +} + +func (h Hooks) AfterUnbondingInitiated(_ context.Context, _ uint64) error { + return nil +} + +func (h Hooks) BeforeTokenizeShareRecordRemoved(_ context.Context, _ uint64) error { + return nil +} diff --git a/x/liquid/keeper/keeper.go b/x/liquid/keeper/keeper.go new file mode 100644 index 00000000..20dddee1 --- /dev/null +++ b/x/liquid/keeper/keeper.go @@ -0,0 +1,61 @@ +package keeper + +import ( + "context" + + storetypes "cosmossdk.io/core/store" + "cosmossdk.io/log" + + "github.com/cosmos/cosmos-sdk/codec" + sdk "github.com/cosmos/cosmos-sdk/types" + + "github.com/KYVENetwork/chain/x/liquid/types" +) + +// Keeper of the x/liquid store +type Keeper struct { + storeService storetypes.KVStoreService + cdc codec.BinaryCodec + authKeeper types.AccountKeeper + bankKeeper types.BankKeeper + stakingKeeper types.StakingKeeper + distKeeper types.DistributionKeeper + authority string +} + +// NewKeeper creates a new liquid Keeper instance +func NewKeeper( + cdc codec.BinaryCodec, + storeService storetypes.KVStoreService, + ak types.AccountKeeper, + bk types.BankKeeper, + sk types.StakingKeeper, + dk types.DistributionKeeper, + authority string, +) *Keeper { + // ensure that authority is a valid AccAddress + if _, err := ak.AddressCodec().StringToBytes(authority); err != nil { + panic("authority is not a valid acc address") + } + + return &Keeper{ + storeService: storeService, + cdc: cdc, + authKeeper: ak, + bankKeeper: bk, + stakingKeeper: sk, + distKeeper: dk, + authority: authority, + } +} + +// Logger returns a module-specific logger. +func (k Keeper) Logger(ctx context.Context) log.Logger { + sdkCtx := sdk.UnwrapSDKContext(ctx) + return sdkCtx.Logger().With("module", "x/"+types.ModuleName) +} + +// GetAuthority returns the x/liquid module's authority. +func (k Keeper) GetAuthority() string { + return k.authority +} diff --git a/x/liquid/keeper/keeper_test.go b/x/liquid/keeper/keeper_test.go new file mode 100644 index 00000000..087a202f --- /dev/null +++ b/x/liquid/keeper/keeper_test.go @@ -0,0 +1,105 @@ +package keeper_test + +import ( + "testing" + + "github.com/stretchr/testify/suite" + + cmtproto "github.com/cometbft/cometbft/proto/tendermint/types" + cmttime "github.com/cometbft/cometbft/types/time" + + sdkmath "cosmossdk.io/math" + storetypes "cosmossdk.io/store/types" + + "github.com/cosmos/cosmos-sdk/baseapp" + "github.com/cosmos/cosmos-sdk/codec/address" + "github.com/cosmos/cosmos-sdk/runtime" + "github.com/cosmos/cosmos-sdk/testutil" + simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims" + sdk "github.com/cosmos/cosmos-sdk/types" + moduletestutil "github.com/cosmos/cosmos-sdk/types/module/testutil" + authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" + govtypes "github.com/cosmos/cosmos-sdk/x/gov/types" + stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" + + lsmkeeper "github.com/KYVENetwork/chain/x/liquid/keeper" + lsmtypes "github.com/KYVENetwork/chain/x/liquid/types" + "github.com/KYVENetwork/chain/x/liquid/types/mocks" +) + +var PKs = simtestutil.CreateTestPubKeys(500) + +type KeeperTestSuite struct { + suite.Suite + + ctx sdk.Context + lsmKeeper *lsmkeeper.Keeper + stakingKeeper *mocks.StakingKeeper + bankKeeper *mocks.BankKeeper + accountKeeper *mocks.AccountKeeper + queryClient lsmtypes.QueryClient + msgServer lsmtypes.MsgServer +} + +func (s *KeeperTestSuite) SetupTest() { + require := s.Require() + key := storetypes.NewKVStoreKey(stakingtypes.StoreKey) + storeService := runtime.NewKVStoreService(key) + testCtx := testutil.DefaultContextWithDB(s.T(), key, storetypes.NewTransientStoreKey("transient_test")) + ctx := testCtx.Ctx.WithBlockHeader(cmtproto.Header{Time: cmttime.Now()}) + encCfg := moduletestutil.MakeTestEncodingConfig() + + accountKeeper := mocks.NewAccountKeeper(s.T()) + accountKeeper.EXPECT().AddressCodec().Return(address.NewBech32Codec("cosmos")) + + bankKeeper := mocks.NewBankKeeper(s.T()) + stakingKeeper := mocks.NewStakingKeeper(s.T()) + distributionKeeper := mocks.NewDistributionKeeper(s.T()) + + stakingKeeper.EXPECT().ValidatorAddressCodec().Return(address.NewBech32Codec("cosmosvaloper")).Maybe() + + lsmKeeper := lsmkeeper.NewKeeper( + encCfg.Codec, + storeService, + accountKeeper, + bankKeeper, + stakingKeeper, + distributionKeeper, + authtypes.NewModuleAddress(govtypes.ModuleName).String(), + ) + require.NoError(lsmKeeper.SetParams(ctx, lsmtypes.DefaultParams())) + + s.ctx = ctx + s.stakingKeeper = stakingKeeper + s.bankKeeper = bankKeeper + s.accountKeeper = accountKeeper + s.lsmKeeper = lsmKeeper + + lsmtypes.RegisterInterfaces(encCfg.InterfaceRegistry) + queryHelper := baseapp.NewQueryServerTestHelper(ctx, encCfg.InterfaceRegistry) + lsmtypes.RegisterQueryServer(queryHelper, lsmkeeper.Querier{Keeper: lsmKeeper}) + s.queryClient = lsmtypes.NewQueryClient(queryHelper) + s.msgServer = lsmkeeper.NewMsgServerImpl(lsmKeeper) +} + +func (s *KeeperTestSuite) TestParams() { + ctx, keeper := s.ctx, s.lsmKeeper + require := s.Require() + + expParams := lsmtypes.DefaultParams() + // check that the empty keeper loads the default + resParams, err := keeper.GetParams(ctx) + require.NoError(err) + require.Equal(expParams, resParams) + + expParams.GlobalLiquidStakingCap = sdkmath.LegacyNewDec(1) + expParams.ValidatorLiquidStakingCap = sdkmath.LegacyNewDec(1) + require.NoError(keeper.SetParams(ctx, expParams)) + resParams, err = keeper.GetParams(ctx) + require.NoError(err) + require.True(expParams.Equal(resParams)) +} + +func TestKeeperTestSuite(t *testing.T) { + suite.Run(t, new(KeeperTestSuite)) +} diff --git a/x/liquid/keeper/liquid_stake.go b/x/liquid/keeper/liquid_stake.go new file mode 100644 index 00000000..37b9ab0a --- /dev/null +++ b/x/liquid/keeper/liquid_stake.go @@ -0,0 +1,488 @@ +package keeper + +import ( + "context" + "time" + + "cosmossdk.io/math" + storetypes "cosmossdk.io/store/types" + + "github.com/cosmos/cosmos-sdk/runtime" + sdk "github.com/cosmos/cosmos-sdk/types" + vesting "github.com/cosmos/cosmos-sdk/x/auth/vesting/exported" + + "github.com/KYVENetwork/chain/x/liquid/types" +) + +// SetTotalLiquidStakedTokens stores the total outstanding tokens owned by a liquid staking provider +func (k Keeper) SetTotalLiquidStakedTokens(ctx context.Context, tokens math.Int) { + store := k.storeService.OpenKVStore(ctx) + + tokensBz, err := tokens.Marshal() + if err != nil { + panic(err) + } + + err = store.Set(types.TotalLiquidStakedTokensKey, tokensBz) + if err != nil { + panic(err) + } +} + +// GetTotalLiquidStakedTokens returns the total outstanding tokens owned by a liquid staking provider +// Returns zero if the total liquid stake amount has not been initialized +func (k Keeper) GetTotalLiquidStakedTokens(ctx context.Context) math.Int { + store := k.storeService.OpenKVStore(ctx) + tokensBz, err := store.Get(types.TotalLiquidStakedTokensKey) + if err != nil { + panic(err) + } + + if tokensBz == nil { + return math.ZeroInt() + } + + var tokens math.Int + if err := tokens.Unmarshal(tokensBz); err != nil { + panic(err) + } + + return tokens +} + +// Checks if an account associated with a given delegation is related to liquid staking +// +// This is determined by checking if the account has a 32-length address +// which will identify the following scenarios: +// - An account has tokenized their shares, and thus the delegation is +// owned by the tokenize share record module account +// - A liquid staking provider is delegating through an ICA account +// +// Both ICA accounts and tokenize share record module accounts have 32-length addresses +// NOTE: This will have to be refactored before adapting it to chains beyond gaia +// as other chains may have 32-length addresses that are not related to the above scenarios +func (k Keeper) DelegatorIsLiquidStaker(delegatorAddress sdk.AccAddress) bool { + return len(delegatorAddress) == 32 +} + +// CheckExceedsGlobalLiquidStakingCap checks if a liquid delegation would cause the +// global liquid staking cap to be exceeded +// A liquid delegation is defined as tokenized shares +// The total stake is determined by the balance of the bonded pool +// If the delegation's shares are already bonded (e.g. in the event of a tokenized share) +// the tokens are already included in the bonded pool +// If the delegation's shares are not bonded (e.g. normal delegation), +// we need to add the tokens to the current bonded pool balance to get the total staked +func (k Keeper) CheckExceedsGlobalLiquidStakingCap(ctx context.Context, tokens math.Int, sharesAlreadyBonded bool) (bool, error) { + liquidStakingCap, err := k.GlobalLiquidStakingCap(ctx) + if err != nil { + return false, err + } + + liquidStakedAmount := k.GetTotalLiquidStakedTokens(ctx) + + // Determine the total stake from the balance of the bonded pool + // If this is not a tokenized delegation, we need to add the tokens to the pool balance since + // they would not have been counted yet + // If this is for a tokenized delegation, the tokens are already included in the pool balance + totalStakedAmount, err := k.stakingKeeper.TotalBondedTokens(ctx) + if err != nil { + return false, err + } + + if !sharesAlreadyBonded { + totalStakedAmount = totalStakedAmount.Add(tokens) + } + + // Calculate the percentage of stake that is liquid + + updatedLiquidStaked := math.LegacyNewDecFromInt(liquidStakedAmount.Add(tokens)) + liquidStakePercent := updatedLiquidStaked.Quo(math.LegacyNewDecFromInt(totalStakedAmount)) + + return liquidStakePercent.GT(liquidStakingCap), nil +} + +// CheckExceedsValidatorLiquidStakingCap checks if a liquid delegation could cause the +// total liquid shares to exceed the liquid staking cap +// A liquid delegation is defined as tokenized shares +// If the liquid delegation's shares are already bonded (e.g. in the event of a tokenized share) +// the tokens are already included in the validator's delegator shares +// If the liquid delegation's shares are not bonded (e.g. normal delegation), +// we need to add the shares to the current validator's delegator shares to get the total shares +// Returns true if the cap is exceeded +func (k Keeper) CheckExceedsValidatorLiquidStakingCap(ctx context.Context, validator types.LiquidValidator, + shares math.LegacyDec, sharesAlreadyBonded bool, +) (bool, error) { + updatedLiquidShares := validator.LiquidShares.Add(shares) + str, err := k.stakingKeeper.ValidatorAddressCodec().StringToBytes(validator.OperatorAddress) + if err != nil { + return false, err + } + stVal, err := k.stakingKeeper.GetValidator(ctx, str) + if err != nil { + return false, err + } + updatedTotalShares := stVal.DelegatorShares + if !sharesAlreadyBonded { + updatedTotalShares = updatedTotalShares.Add(shares) + } + + liquidStakePercent := updatedLiquidShares.Quo(updatedTotalShares) + liquidStakingCap, err := k.ValidatorLiquidStakingCap(ctx) + if err != nil { + return false, err + } + + return liquidStakePercent.GT(liquidStakingCap), nil +} + +// SafelyIncreaseTotalLiquidStakedTokens increments the total liquid staked tokens +// if the global cap is not surpassed by this delegation +// +// The percentage of liquid staked tokens must be less than the GlobalLiquidStakingCap: +// (TotalLiquidStakedTokens / TotalStakedTokens) <= GlobalLiquidStakingCap +func (k Keeper) SafelyIncreaseTotalLiquidStakedTokens(ctx context.Context, amount math.Int, sharesAlreadyBonded bool) error { + exceedsCap, err := k.CheckExceedsGlobalLiquidStakingCap(ctx, amount, sharesAlreadyBonded) + if err != nil { + return err + } + + if exceedsCap { + return types.ErrGlobalLiquidStakingCapExceeded + } + + k.SetTotalLiquidStakedTokens(ctx, k.GetTotalLiquidStakedTokens(ctx).Add(amount)) + return nil +} + +// DecreaseTotalLiquidStakedTokens decrements the total liquid staked tokens +func (k Keeper) DecreaseTotalLiquidStakedTokens(ctx context.Context, amount math.Int) error { + totalLiquidStake := k.GetTotalLiquidStakedTokens(ctx) + if amount.GT(totalLiquidStake) { + return types.ErrTotalLiquidStakedUnderflow + } + k.SetTotalLiquidStakedTokens(ctx, totalLiquidStake.Sub(amount)) + return nil +} + +// SafelyIncreaseValidatorLiquidShares increments the liquid shares on a validator, if: +// the validator liquid staking cap will not be exceeded by this delegation +// +// The percentage of validator liquid shares must be less than the ValidatorLiquidStakingCap: +// (TotalLiquidStakedTokens / TotalStakedTokens) <= ValidatorLiquidStakingCap +func (k Keeper) SafelyIncreaseValidatorLiquidShares( + ctx context.Context, + valAddress sdk.ValAddress, + shares math.LegacyDec, + sharesAlreadyBonded bool, +) (types.LiquidValidator, error) { + validator, err := k.GetLiquidValidator(ctx, valAddress) + if err != nil { + return validator, err + } + + exceedsValidatorLiquidStakingCap, err := k.CheckExceedsValidatorLiquidStakingCap(ctx, validator, shares, sharesAlreadyBonded) + if err != nil { + return validator, err + } + + if exceedsValidatorLiquidStakingCap { + return validator, types.ErrValidatorLiquidStakingCapExceeded + } + + // Increment the validator's liquid shares + validator.LiquidShares = validator.LiquidShares.Add(shares) + err = k.SetLiquidValidator(ctx, validator) + if err != nil { + return types.LiquidValidator{}, err + } + + return validator, nil +} + +// DecreaseValidatorLiquidShares decrements the liquid shares on a validator +func (k Keeper) DecreaseValidatorLiquidShares(ctx context.Context, valAddress sdk.ValAddress, + shares math.LegacyDec, +) (types.LiquidValidator, error) { + validator, err := k.GetLiquidValidator(ctx, valAddress) + if err != nil { + return validator, err + } + + if shares.GT(validator.LiquidShares) { + return validator, types.ErrValidatorLiquidSharesUnderflow + } + + validator.LiquidShares = validator.LiquidShares.Sub(shares) + err = k.SetLiquidValidator(ctx, validator) + if err != nil { + return types.LiquidValidator{}, err + } + + return validator, nil +} + +// Adds a lock that prevents tokenizing shares for an account +// The tokenize share lock store is implemented by keying on the account address +// and storing a timestamp as the value. The timestamp is empty when the lock is +// set and gets populated with the unlock completion time once the unlock has started +func (k Keeper) AddTokenizeSharesLock(ctx context.Context, address sdk.AccAddress) { + store := k.storeService.OpenKVStore(ctx) + key := types.GetTokenizeSharesLockKey(address) + err := store.Set(key, sdk.FormatTimeBytes(time.Time{})) + if err != nil { + panic(err) + } +} + +// Removes the tokenize share lock for an account to enable tokenizing shares +func (k Keeper) RemoveTokenizeSharesLock(ctx context.Context, address sdk.AccAddress) { + store := k.storeService.OpenKVStore(ctx) + key := types.GetTokenizeSharesLockKey(address) + err := store.Delete(key) + if err != nil { + panic(err) + } +} + +// Updates the timestamp associated with a lock to the time at which the lock expires +func (k Keeper) SetTokenizeSharesUnlockTime(ctx context.Context, address sdk.AccAddress, completionTime time.Time) { + store := k.storeService.OpenKVStore(ctx) + key := types.GetTokenizeSharesLockKey(address) + err := store.Set(key, sdk.FormatTimeBytes(completionTime)) + if err != nil { + panic(err) + } +} + +// Checks if there is currently a tokenize share lock for a given account +// Returns the status indicating whether the account is locked, unlocked, +// or as a lock expiring. If the lock is expiring, the expiration time is returned +func (k Keeper) GetTokenizeSharesLock(ctx context.Context, address sdk.AccAddress) (status types.TokenizeShareLockStatus, unlockTime time.Time) { + store := k.storeService.OpenKVStore(ctx) + key := types.GetTokenizeSharesLockKey(address) + bz, err := store.Get(key) + if err != nil { + panic(err) + } + + if len(bz) == 0 { + return types.TOKENIZE_SHARE_LOCK_STATUS_UNLOCKED, time.Time{} + } + unlockTime, err = sdk.ParseTimeBytes(bz) + if err != nil { + panic(err) + } + if unlockTime.IsZero() { + return types.TOKENIZE_SHARE_LOCK_STATUS_LOCKED, time.Time{} + } + return types.TOKENIZE_SHARE_LOCK_STATUS_LOCK_EXPIRING, unlockTime +} + +// Returns all tokenize share locks +func (k Keeper) GetAllTokenizeSharesLocks(ctx context.Context) (tokenizeShareLocks []types.TokenizeShareLock) { + store := runtime.KVStoreAdapter(k.storeService.OpenKVStore(ctx)) + + iterator := storetypes.KVStorePrefixIterator(store, types.TokenizeSharesLockPrefix) + defer iterator.Close() + + for ; iterator.Valid(); iterator.Next() { + addressBz := iterator.Key()[2:] // remove prefix bytes and address length + unlockTime, err := sdk.ParseTimeBytes(iterator.Value()) + if err != nil { + panic(err) + } + + var status types.TokenizeShareLockStatus + if unlockTime.IsZero() { + status = types.TOKENIZE_SHARE_LOCK_STATUS_LOCKED + } else { + status = types.TOKENIZE_SHARE_LOCK_STATUS_LOCK_EXPIRING + } + + bechPrefix := sdk.GetConfig().GetBech32AccountAddrPrefix() + lock := types.TokenizeShareLock{ + Address: sdk.MustBech32ifyAddressBytes(bechPrefix, addressBz), + Status: status.String(), + CompletionTime: unlockTime, + } + + tokenizeShareLocks = append(tokenizeShareLocks, lock) + } + + return tokenizeShareLocks +} + +// Stores a list of addresses pending tokenize share unlocking at the same time +func (k Keeper) SetPendingTokenizeShareAuthorizations(ctx context.Context, completionTime time.Time, authorizations types.PendingTokenizeShareAuthorizations) { + store := k.storeService.OpenKVStore(ctx) + timeKey := types.GetTokenizeShareAuthorizationTimeKey(completionTime) + bz := k.cdc.MustMarshal(&authorizations) + err := store.Set(timeKey, bz) + if err != nil { + panic(err) + } +} + +// Returns a list of addresses pending tokenize share unlocking at the same time +func (k Keeper) GetPendingTokenizeShareAuthorizations(ctx context.Context, completionTime time.Time) types.PendingTokenizeShareAuthorizations { + store := k.storeService.OpenKVStore(ctx) + + timeKey := types.GetTokenizeShareAuthorizationTimeKey(completionTime) + bz, err := store.Get(timeKey) + if err != nil { + panic(err) + } + + authorizations := types.PendingTokenizeShareAuthorizations{Addresses: []string{}} + if len(bz) == 0 { + return authorizations + } + k.cdc.MustUnmarshal(bz, &authorizations) + + return authorizations +} + +// Inserts the address into a queue where it will sit for 1 unbonding period +// before the tokenize share lock is removed +// Returns the completion time +func (k Keeper) QueueTokenizeSharesAuthorization(ctx context.Context, address sdk.AccAddress) (time.Time, error) { + sdkCtx := sdk.UnwrapSDKContext(ctx) + blockTime := sdkCtx.BlockTime() + + params, err := k.stakingKeeper.GetParams(ctx) + if err != nil { + return blockTime, err + } + + completionTime := blockTime.Add(params.UnbondingTime) + + // Append the address to the list of addresses that also unlock at this time + authorizations := k.GetPendingTokenizeShareAuthorizations(ctx, completionTime) + authorizations.Addresses = append(authorizations.Addresses, address.String()) + + k.SetPendingTokenizeShareAuthorizations(ctx, completionTime, authorizations) + k.SetTokenizeSharesUnlockTime(ctx, address, completionTime) + + return completionTime, nil +} + +// Cancels a pending tokenize share authorization by removing the lock from the queue +func (k Keeper) CancelTokenizeShareLockExpiration(ctx context.Context, address sdk.AccAddress, completionTime time.Time) { + authorizations := k.GetPendingTokenizeShareAuthorizations(ctx, completionTime) + + updatedAddresses := []string{} + for _, expiringAddress := range authorizations.Addresses { + if address.String() != expiringAddress { + updatedAddresses = append(updatedAddresses, expiringAddress) + } + } + + authorizations.Addresses = updatedAddresses + k.SetPendingTokenizeShareAuthorizations(ctx, completionTime, authorizations) +} + +// Unlocks all queued tokenize share authorizations that have matured +// (i.e. have waited the full unbonding period) +func (k Keeper) RemoveExpiredTokenizeShareLocks(ctx context.Context, blockTime time.Time) ([]string, error) { + store := k.storeService.OpenKVStore(ctx) + + // iterators all time slices from time 0 until the current block time + prefixEnd := storetypes.InclusiveEndBytes(types.GetTokenizeShareAuthorizationTimeKey(blockTime)) + iterator, err := store.Iterator(types.TokenizeSharesUnlockQueuePrefix, prefixEnd) + if err != nil { + return []string{}, err + } + + defer iterator.Close() + + // collect all unlocked addresses + unlockedAddresses := []string{} + keys := [][]byte{} + for ; iterator.Valid(); iterator.Next() { + authorizations := types.PendingTokenizeShareAuthorizations{} + k.cdc.MustUnmarshal(iterator.Value(), &authorizations) + unlockedAddresses = append(unlockedAddresses, authorizations.Addresses...) + keys = append(keys, iterator.Key()) + } + + // delete unlocked addresses keys + for _, k := range keys { + err := store.Delete(k) + if err != nil { + panic(err) + } + } + + // remove the lock from each unlocked address + for _, unlockedAddress := range unlockedAddresses { + unlockedAddr, err := k.authKeeper.AddressCodec().StringToBytes(unlockedAddress) + if err != nil { + return unlockedAddresses, err + } + k.RemoveTokenizeSharesLock(ctx, unlockedAddr) + } + + return unlockedAddresses, nil +} + +// CheckVestedDelegationInVestingAccount verifies whether the provided vesting account +// holds a vested delegation for an equal or greater amount of the specified coin +// at the given block time. +// +// Note that this function facilitates a specific use-case in the LSM module for tokenizing vested delegations. +// For more details, see https://github.com/cosmos/gaia/issues/2877. +func CheckVestedDelegationInVestingAccount(account vesting.VestingAccount, blockTime time.Time, coin sdk.Coin) bool { + // Get the vesting coins at the current block time + vestingAmount := account.GetVestingCoins(blockTime).AmountOf(coin.Denom) + + // Note that the "DelegatedVesting" and "DelegatedFree" values + // were computed during the last delegation or undelegation operation + delVestingAmount := account.GetDelegatedVesting().AmountOf(coin.Denom) + delVested := account.GetDelegatedFree() + + // Calculate the new vested delegated coins + x := math.MinInt(vestingAmount.Sub(delVestingAmount), math.ZeroInt()) + + // Add the newly vested delegated coins to the existing delegated vested amount + if !x.IsZero() { + delVested = delVested.Add(sdk.NewCoin(coin.Denom, x.Abs())) + } + + // Check if the total delegated vested amount is greater than or equal to the specified coin amount + return delVested.AmountOf(coin.Denom).GTE(coin.Amount) +} + +// SetLiquidValidator sets the main record holding liquid validator details +func (k Keeper) SetLiquidValidator(ctx context.Context, validator types.LiquidValidator) error { + store := k.storeService.OpenKVStore(ctx) + bz := types.MustMarshalValidator(k.cdc, &validator) + str, err := k.stakingKeeper.ValidatorAddressCodec().StringToBytes(validator.OperatorAddress) + if err != nil { + return err + } + return store.Set(types.GetLiquidValidatorKey(str), bz) +} + +// GetLiquidValidator gets a liquid validator record +func (k Keeper) GetLiquidValidator(ctx context.Context, addr sdk.ValAddress) (validator types.LiquidValidator, + err error, +) { + store := k.storeService.OpenKVStore(ctx) + value, err := store.Get(types.GetLiquidValidatorKey(addr)) + if err != nil { + return validator, err + } + + if value == nil { + return validator, types.ErrNoValidatorFound + } + + return types.UnmarshalValidator(k.cdc, value) +} + +// RemoveLiquidValidator delete the LiquidValidator record +func (k Keeper) RemoveLiquidValidator(ctx context.Context, addr sdk.ValAddress) error { + store := k.storeService.OpenKVStore(ctx) + return store.Delete(types.GetLiquidValidatorKey(addr)) +} diff --git a/x/liquid/keeper/liquid_stake_test.go b/x/liquid/keeper/liquid_stake_test.go new file mode 100644 index 00000000..91c445c8 --- /dev/null +++ b/x/liquid/keeper/liquid_stake_test.go @@ -0,0 +1,716 @@ +package keeper_test + +import ( + "time" + + "github.com/stretchr/testify/mock" + + "cosmossdk.io/math" + + "github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1" + simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/types/address" + authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" + vestingtypes "github.com/cosmos/cosmos-sdk/x/auth/vesting/types" + stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" + + lsmkeeper "github.com/KYVENetwork/chain/x/liquid/keeper" + "github.com/KYVENetwork/chain/x/liquid/types" +) + +// Tests Set/Get TotalLiquidStakedTokens +func (s *KeeperTestSuite) TestTotalLiquidStakedTokens() { + ctx, keeper := s.ctx, s.lsmKeeper + require := s.Require() + + // Update the total liquid staked + total := math.NewInt(100) + keeper.SetTotalLiquidStakedTokens(ctx, total) + + // Confirm it was updated + require.Equal(total, keeper.GetTotalLiquidStakedTokens(ctx), "initial") +} + +// Tests Increase/Decrease TotalValidatorLiquidShares +func (s *KeeperTestSuite) TestValidatorLiquidShares() { + ctx, keeper := s.ctx, s.lsmKeeper + + // Create a validator address + privKey := secp256k1.GenPrivKey() + pubKey := privKey.PubKey() + valAddress := sdk.ValAddress(pubKey.Address()) + + // Set an initial total + initial := math.LegacyNewDec(100) + validator := types.LiquidValidator{ + OperatorAddress: valAddress.String(), + LiquidShares: initial, + } + s.Require().NoError(keeper.SetLiquidValidator(ctx, validator)) +} + +// Tests DecreaseTotalLiquidStakedTokens +func (s *KeeperTestSuite) TestDecreaseTotalLiquidStakedTokens() { + ctx, keeper := s.ctx, s.lsmKeeper + require := s.Require() + + intitialTotalLiquidStaked := math.NewInt(100) + decreaseAmount := math.NewInt(10) + + // Set the total liquid staked to an arbitrary value + keeper.SetTotalLiquidStakedTokens(ctx, intitialTotalLiquidStaked) + + // Decrease the total liquid stake and confirm the total was updated + err := keeper.DecreaseTotalLiquidStakedTokens(ctx, decreaseAmount) + require.NoError(err, "no error expected when decreasing total liquid staked tokens") + require.Equal(intitialTotalLiquidStaked.Sub(decreaseAmount), keeper.GetTotalLiquidStakedTokens(ctx)) + + // Attempt to decrease by an excessive amount, it should error + err = keeper.DecreaseTotalLiquidStakedTokens(ctx, intitialTotalLiquidStaked) + require.ErrorIs(err, types.ErrTotalLiquidStakedUnderflow) +} + +// Tests TestCheckExceedsValidatorLiquidStakingCap +func (s *KeeperTestSuite) TestCheckExceedsValidatorLiquidStakingCap() { + ctx, keeper := s.ctx, s.lsmKeeper + require := s.Require() + + testCases := []struct { + name string + validatorLiquidCap math.LegacyDec + validatorLiquidShares math.LegacyDec + validatorTotalShares math.LegacyDec + newLiquidShares math.LegacyDec + tokenizingShares bool + expectedExceeds bool + }{ + { + // Cap: 10% - Delegation Below Threshold + // Liquid Shares: 5, Total Shares: 95, New Liquid Shares: 1 + // => Liquid Shares: 5+1=6, Total Shares: 95+1=96 => 6/96 = 6% < 10% cap + name: "10 percent cap _ native delegation _ below cap", + validatorLiquidCap: math.LegacyMustNewDecFromStr("0.1"), + validatorLiquidShares: math.LegacyNewDec(5), + validatorTotalShares: math.LegacyNewDec(95), + newLiquidShares: math.LegacyNewDec(1), + tokenizingShares: false, + expectedExceeds: false, + }, + { + // Cap: 10% - Delegation At Threshold + // Liquid Shares: 5, Total Shares: 95, New Liquid Shares: 5 + // => Liquid Shares: 5+5=10, Total Shares: 95+5=100 => 10/100 = 10% == 10% cap + name: "10 percent cap _ native delegation _ equals cap", + validatorLiquidCap: math.LegacyMustNewDecFromStr("0.1"), + validatorLiquidShares: math.LegacyNewDec(5), + validatorTotalShares: math.LegacyNewDec(95), + newLiquidShares: math.LegacyNewDec(4), + tokenizingShares: false, + expectedExceeds: false, + }, + { + // Cap: 10% - Delegation Exceeds Threshold + // Liquid Shares: 5, Total Shares: 95, New Liquid Shares: 6 + // => Liquid Shares: 5+6=11, Total Shares: 95+6=101 => 11/101 = 11% > 10% cap + name: "10 percent cap _ native delegation _ exceeds cap", + validatorLiquidCap: math.LegacyMustNewDecFromStr("0.1"), + validatorLiquidShares: math.LegacyNewDec(5), + validatorTotalShares: math.LegacyNewDec(95), + newLiquidShares: math.LegacyNewDec(6), + tokenizingShares: false, + expectedExceeds: true, + }, + { + // Cap: 20% - Delegation Below Threshold + // Liquid Shares: 20, Total Shares: 220, New Liquid Shares: 29 + // => Liquid Shares: 20+29=49, Total Shares: 220+29=249 => 49/249 = 19% < 20% cap + name: "20 percent cap _ native delegation _ below cap", + validatorLiquidCap: math.LegacyMustNewDecFromStr("0.2"), + validatorLiquidShares: math.LegacyNewDec(20), + validatorTotalShares: math.LegacyNewDec(220), + newLiquidShares: math.LegacyNewDec(29), + tokenizingShares: false, + expectedExceeds: false, + }, + { + // Cap: 20% - Delegation At Threshold + // Liquid Shares: 20, Total Shares: 220, New Liquid Shares: 30 + // => Liquid Shares: 20+30=50, Total Shares: 220+30=250 => 50/250 = 20% == 20% cap + name: "20 percent cap _ native delegation _ equals cap", + validatorLiquidCap: math.LegacyMustNewDecFromStr("0.2"), + validatorLiquidShares: math.LegacyNewDec(20), + validatorTotalShares: math.LegacyNewDec(220), + newLiquidShares: math.LegacyNewDec(30), + tokenizingShares: false, + expectedExceeds: false, + }, + { + // Cap: 20% - Delegation Exceeds Threshold + // Liquid Shares: 20, Total Shares: 220, New Liquid Shares: 31 + // => Liquid Shares: 20+31=51, Total Shares: 220+31=251 => 51/251 = 21% > 20% cap + name: "20 percent cap _ native delegation _ exceeds cap", + validatorLiquidCap: math.LegacyMustNewDecFromStr("0.2"), + validatorLiquidShares: math.LegacyNewDec(20), + validatorTotalShares: math.LegacyNewDec(220), + newLiquidShares: math.LegacyNewDec(31), + tokenizingShares: false, + expectedExceeds: true, + }, + { + // Cap: 50% - Native Delegation - Delegation At Threshold + // Liquid shares: 0, Total Shares: 100, New Liquid Shares: 50 + // Total Liquid Shares: 0+50=50, Total Shares: 100+50=150 + // => 50/150 = 33% < 50% cap + name: "50 percent cap _ native delegation _ delegation equals cap", + validatorLiquidCap: math.LegacyMustNewDecFromStr("0.5"), + validatorLiquidShares: math.LegacyNewDec(0), + validatorTotalShares: math.LegacyNewDec(100), + newLiquidShares: math.LegacyNewDec(50), + tokenizingShares: false, + expectedExceeds: false, + }, + { + // Cap: 50% - Tokenized Delegation - Delegation At Threshold + // Liquid shares: 0, Total Shares: 100, New Liquid Shares: 50 + // Total Liquid Shares => 0+50=50, Total Shares: 100, New Liquid Shares: 50 + // => 50 / 100 = 50% == 50% cap + name: "50 percent cap _ tokenized delegation _ delegation equals cap", + validatorLiquidCap: math.LegacyMustNewDecFromStr("0.5"), + validatorLiquidShares: math.LegacyNewDec(0), + validatorTotalShares: math.LegacyNewDec(100), + newLiquidShares: math.LegacyNewDec(50), + tokenizingShares: true, + expectedExceeds: false, + }, + { + // Cap: 50% - Native Delegation - Delegation At Threshold + // Liquid shares: 0, Total Shares: 100, New Liquid Shares: 51 + // Total Liquid Shares: 0+51=51, Total Shares: 100+51=151 + // => 51/150 = 33% < 50% cap + name: "50 percent cap _ native delegation _ delegation equals cap", + validatorLiquidCap: math.LegacyMustNewDecFromStr("0.5"), + validatorLiquidShares: math.LegacyNewDec(0), + validatorTotalShares: math.LegacyNewDec(100), + newLiquidShares: math.LegacyNewDec(51), + tokenizingShares: false, + expectedExceeds: false, + }, + { + // Cap: 50% - Tokenized Delegation - Delegation At Threshold + // Liquid shares: 0, Total Shares: 100, New Liquid Shares: 50 + // Total Liquid Shares => 0+51=51, Total Shares: 100, New Liquid Shares: 51 + // => 51 / 100 = 51% > 50% cap + name: "50 percent cap _ tokenized delegation _ delegation equals cap", + validatorLiquidCap: math.LegacyMustNewDecFromStr("0.5"), + validatorLiquidShares: math.LegacyNewDec(0), + validatorTotalShares: math.LegacyNewDec(100), + newLiquidShares: math.LegacyNewDec(51), + tokenizingShares: true, + expectedExceeds: true, + }, + { + // Cap of 0% - everything should exceed + name: "0 percent cap", + validatorLiquidCap: math.LegacyZeroDec(), + validatorLiquidShares: math.LegacyNewDec(0), + validatorTotalShares: math.LegacyNewDec(1_000_000), + newLiquidShares: math.LegacyNewDec(1), + tokenizingShares: false, + expectedExceeds: true, + }, + { + // Cap of 100% - nothing should exceed + name: "100 percent cap", + validatorLiquidCap: math.LegacyOneDec(), + validatorLiquidShares: math.LegacyNewDec(1), + validatorTotalShares: math.LegacyNewDec(1_000_000), + newLiquidShares: math.LegacyNewDec(1), + tokenizingShares: false, + expectedExceeds: false, + }, + } + + for _, tc := range testCases { + s.Run(tc.name, func() { + // Update the validator liquid staking cap + params, err := keeper.GetParams(ctx) + require.NoError(err) + params.ValidatorLiquidStakingCap = tc.validatorLiquidCap + require.NoError(keeper.SetParams(ctx, params)) + + call := s.stakingKeeper.EXPECT().GetValidator(ctx, mock.Anything).Return( + stakingtypes.Validator{DelegatorShares: tc.validatorTotalShares}, + nil, + ) + // Generate a test validator address + privKey := secp256k1.GenPrivKey() + pubKey := privKey.PubKey() + valAddress := sdk.ValAddress(pubKey.Address()) + // Create a validator with designated self-bond shares + validator := types.LiquidValidator{ + OperatorAddress: valAddress.String(), + LiquidShares: tc.validatorLiquidShares, + } + + // Check whether the cap is exceeded + actualExceeds, err := keeper.CheckExceedsValidatorLiquidStakingCap(ctx, validator, tc.newLiquidShares, tc.tokenizingShares) + require.NoError(err) + require.Equal(tc.expectedExceeds, actualExceeds, tc.name) + call.Unset() + }) + } +} + +// Tests SafelyIncreaseValidatorLiquidShares +func (s *KeeperTestSuite) TestSafelyIncreaseValidatorLiquidShares() { + ctx, keeper := s.ctx, s.lsmKeeper + require := s.Require() + + // Generate a test validator address + privKey := secp256k1.GenPrivKey() + pubKey := privKey.PubKey() + valAddress := sdk.ValAddress(pubKey.Address()) + + // Helper function to check the validator's liquid shares + checkValidatorLiquidShares := func(expected math.LegacyDec, description string) { + actualValidator, err := keeper.GetLiquidValidator(ctx, valAddress) + require.NoError(err) + require.Equal(expected.TruncateInt64(), actualValidator.LiquidShares.TruncateInt64(), description) + } + + // Start with the following: + // Initial Liquid Shares: 0 + // Validator TotalShares: 75 + // + // Initial Caps: + // ValidatorLiquidStakingCap: 25% (Cap applied at 25 shares) + // + // Cap Increases: + // ValidatorLiquidStakingCap: 40% (Cap applied at 50 shares) + initialLiquidShares := math.LegacyNewDec(0) + validatorTotalShares := math.LegacyNewDec(75) + + firstIncreaseAmount := math.LegacyNewDec(20) + secondIncreaseAmount := math.LegacyNewDec(10) // total increase of 30 + + initialLiquidStakingCap := math.LegacyMustNewDecFromStr("0.25") + finalLiquidStakingCap := math.LegacyMustNewDecFromStr("0.4") + + stVal := stakingtypes.Validator{ + OperatorAddress: valAddress.String(), + DelegatorShares: validatorTotalShares, + } + call := s.stakingKeeper.EXPECT().GetValidator(ctx, valAddress).Return(stVal, nil) + defer call.Unset() + // Create a validator with designated self-bond shares + initialValidator := types.LiquidValidator{ + OperatorAddress: valAddress.String(), + LiquidShares: initialLiquidShares, + } + require.NoError(keeper.SetLiquidValidator(ctx, initialValidator)) + + // Set validator bond factor to a small number such that any delegation would fail, + // and set the liquid staking cap such that the first stake would succeed, but the second + // would fail + params, err := keeper.GetParams(ctx) + require.NoError(err) + params.ValidatorLiquidStakingCap = initialLiquidStakingCap + require.NoError(keeper.SetParams(ctx, params)) + + // Try the increase and check that it succeeded + expectedLiquidSharesAfterFirstStake := initialLiquidShares.Add(firstIncreaseAmount) + _, err = keeper.SafelyIncreaseValidatorLiquidShares(ctx, valAddress, firstIncreaseAmount, false) + require.NoError(err) + checkValidatorLiquidShares(expectedLiquidSharesAfterFirstStake, "shares with cap loose bond cap") + + // Attempt another increase, it should fail from the liquid staking cap + _, err = keeper.SafelyIncreaseValidatorLiquidShares(ctx, valAddress, secondIncreaseAmount, false) + require.ErrorIs(err, types.ErrValidatorLiquidStakingCapExceeded) + checkValidatorLiquidShares(expectedLiquidSharesAfterFirstStake, "shares after liquid staking cap hit") + + // Raise the liquid staking cap so the new increment succeeds + params.ValidatorLiquidStakingCap = finalLiquidStakingCap + require.NoError(keeper.SetParams(ctx, params)) + + // Finally confirm that the increase succeeded this time + expectedLiquidSharesAfterSecondStake := expectedLiquidSharesAfterFirstStake.Add(secondIncreaseAmount) + _, err = keeper.SafelyIncreaseValidatorLiquidShares(ctx, valAddress, secondIncreaseAmount, false) + require.NoError(err, "no error expected after increasing liquid staking cap") + checkValidatorLiquidShares(expectedLiquidSharesAfterSecondStake, "shares after loose liquid stake cap") +} + +// Tests DecreaseValidatorLiquidShares +func (s *KeeperTestSuite) TestDecreaseValidatorLiquidShares() { + ctx, keeper := s.ctx, s.lsmKeeper + require := s.Require() + + initialLiquidShares := math.LegacyNewDec(100) + decreaseAmount := math.LegacyNewDec(10) + + // Create a validator with designated self-bond shares + privKey := secp256k1.GenPrivKey() + pubKey := privKey.PubKey() + valAddress := sdk.ValAddress(pubKey.Address()) + + initialValidator := types.LiquidValidator{ + OperatorAddress: valAddress.String(), + LiquidShares: initialLiquidShares, + } + require.NoError(keeper.SetLiquidValidator(ctx, initialValidator)) + + // Decrease the validator liquid shares, and confirm the new share amount has been updated + _, err := keeper.DecreaseValidatorLiquidShares(ctx, valAddress, decreaseAmount) + require.NoError(err, "no error expected when decreasing validator liquid shares") + + actualValidator, err := keeper.GetLiquidValidator(ctx, valAddress) + require.NoError(err) + require.Equal(initialLiquidShares.Sub(decreaseAmount), actualValidator.LiquidShares, "liquid shares") + + // Attempt to decrease by a larger amount than it has, it should fail + _, err = keeper.DecreaseValidatorLiquidShares(ctx, valAddress, initialLiquidShares) + require.ErrorIs(err, types.ErrValidatorLiquidSharesUnderflow) +} + +// Tests Add/Remove/Get/SetTokenizeSharesLock +func (s *KeeperTestSuite) TestTokenizeSharesLock() { + ctx, keeper := s.ctx, s.lsmKeeper + require := s.Require() + + addresses := simtestutil.CreateIncrementalAccounts(2) + addressA, addressB := addresses[0], addresses[1] + + unlocked := types.TOKENIZE_SHARE_LOCK_STATUS_UNLOCKED.String() + locked := types.TOKENIZE_SHARE_LOCK_STATUS_LOCKED.String() + lockExpiring := types.TOKENIZE_SHARE_LOCK_STATUS_LOCK_EXPIRING.String() + + // Confirm both accounts start unlocked + status, _ := keeper.GetTokenizeSharesLock(ctx, addressA) + require.Equal(unlocked, status.String(), "addressA unlocked at start") + + status, _ = keeper.GetTokenizeSharesLock(ctx, addressB) + require.Equal(unlocked, status.String(), "addressB unlocked at start") + + // Lock the first account + keeper.AddTokenizeSharesLock(ctx, addressA) + + // The first account should now have tokenize shares disabled + // and the unlock time should be the zero time + status, _ = keeper.GetTokenizeSharesLock(ctx, addressA) + require.Equal(locked, status.String(), "addressA locked") + + status, _ = keeper.GetTokenizeSharesLock(ctx, addressB) + require.Equal(unlocked, status.String(), "addressB still unlocked") + + // Update the lock time and confirm it was set + expectedUnlockTime := time.Date(2023, 1, 1, 0, 0, 0, 0, time.UTC) + keeper.SetTokenizeSharesUnlockTime(ctx, addressA, expectedUnlockTime) + + status, actualUnlockTime := keeper.GetTokenizeSharesLock(ctx, addressA) + require.Equal(lockExpiring, status.String(), "addressA lock expiring") + require.Equal(expectedUnlockTime, actualUnlockTime, "addressA unlock time") + + // Confirm B is still unlocked + status, _ = keeper.GetTokenizeSharesLock(ctx, addressB) + require.Equal(unlocked, status.String(), "addressB still unlocked") + + // Remove the lock + keeper.RemoveTokenizeSharesLock(ctx, addressA) + status, _ = keeper.GetTokenizeSharesLock(ctx, addressA) + require.Equal(unlocked, status.String(), "addressA unlocked at end") + + status, _ = keeper.GetTokenizeSharesLock(ctx, addressB) + require.Equal(unlocked, status.String(), "addressB unlocked at end") +} + +// Tests GetAllTokenizeSharesLocks +func (s *KeeperTestSuite) TestGetAllTokenizeSharesLocks() { + ctx, keeper := s.ctx, s.lsmKeeper + require := s.Require() + + addresses := simtestutil.CreateIncrementalAccounts(4) + + // Set 2 locked accounts, and two accounts with a lock expiring + keeper.AddTokenizeSharesLock(ctx, addresses[0]) + keeper.AddTokenizeSharesLock(ctx, addresses[1]) + + unlockTime1 := time.Date(2023, 1, 1, 1, 0, 0, 0, time.UTC) + unlockTime2 := time.Date(2023, 1, 2, 1, 0, 0, 0, time.UTC) + keeper.SetTokenizeSharesUnlockTime(ctx, addresses[2], unlockTime1) + keeper.SetTokenizeSharesUnlockTime(ctx, addresses[3], unlockTime2) + + // Defined expected locks after GetAll + expectedLocks := map[string]types.TokenizeShareLock{ + addresses[0].String(): { + Status: types.TOKENIZE_SHARE_LOCK_STATUS_LOCKED.String(), + }, + addresses[1].String(): { + Status: types.TOKENIZE_SHARE_LOCK_STATUS_LOCKED.String(), + }, + addresses[2].String(): { + Status: types.TOKENIZE_SHARE_LOCK_STATUS_LOCK_EXPIRING.String(), + CompletionTime: unlockTime1, + }, + addresses[3].String(): { + Status: types.TOKENIZE_SHARE_LOCK_STATUS_LOCK_EXPIRING.String(), + CompletionTime: unlockTime2, + }, + } + + // Check output from GetAll + actualLocks := keeper.GetAllTokenizeSharesLocks(ctx) + require.Len(actualLocks, len(expectedLocks), "number of locks") + + for i, actual := range actualLocks { + expected, ok := expectedLocks[actual.Address] + require.True(ok, "address %s not expected", actual.Address) + require.Equal(expected.Status, actual.Status, "tokenize share lock #%d status", i) + require.Equal(expected.CompletionTime, actual.CompletionTime, "tokenize share lock #%d completion time", i) + } +} + +// Test Get/SetPendingTokenizeShareAuthorizations +func (s *KeeperTestSuite) TestPendingTokenizeShareAuthorizations() { + ctx, keeper := s.ctx, s.lsmKeeper + require := s.Require() + + // Create dummy accounts and completion times + + addresses := simtestutil.CreateIncrementalAccounts(4) + addressStrings := []string{} + for _, address := range addresses { + addressStrings = append(addressStrings, address.String()) + } + + timeA := time.Date(2023, 1, 1, 0, 0, 0, 0, time.UTC) + timeB := timeA.Add(time.Hour) + + // There should be no addresses returned originally + authorizationsA := keeper.GetPendingTokenizeShareAuthorizations(ctx, timeA) + require.Empty(authorizationsA.Addresses, "no addresses at timeA expected") + + authorizationsB := keeper.GetPendingTokenizeShareAuthorizations(ctx, timeB) + require.Empty(authorizationsB.Addresses, "no addresses at timeB expected") + + // Store addresses for timeB + keeper.SetPendingTokenizeShareAuthorizations(ctx, timeB, types.PendingTokenizeShareAuthorizations{ + Addresses: addressStrings, + }) + + // Check addresses + authorizationsA = keeper.GetPendingTokenizeShareAuthorizations(ctx, timeA) + require.Empty(authorizationsA.Addresses, "no addresses at timeA expected at end") + + authorizationsB = keeper.GetPendingTokenizeShareAuthorizations(ctx, timeB) + require.Equal(addressStrings, authorizationsB.Addresses, "address length") +} + +// Test QueueTokenizeSharesAuthorization and RemoveExpiredTokenizeShareLocks +func (s *KeeperTestSuite) TestTokenizeShareAuthorizationQueue() { + ctx, keeper := s.ctx, s.lsmKeeper + require := s.Require() + + // Create dummy accounts and completion times + + // We'll start by adding the following addresses to the queue + // Time 0: [address0] + // Time 1: [] + // Time 2: [address1, address2, address3] + // Time 3: [address4, address5] + // Time 4: [address6] + addresses := simtestutil.CreateIncrementalAccounts(7) + addressesByTime := map[int][]sdk.AccAddress{ + 0: {addresses[0]}, + 1: {}, + 2: {addresses[1], addresses[2], addresses[3]}, + 3: {addresses[4], addresses[5]}, + 4: {addresses[6]}, + } + + // Add each address to the queue and then increment the block time + // such that the times line up as follows + // Time 0: 2023-01-01 00:00:00 + // Time 1: 2023-01-01 00:01:00 + // Time 2: 2023-01-01 00:02:00 + // Time 3: 2023-01-01 00:03:00 + startTime := time.Date(2023, 1, 1, 0, 0, 0, 0, time.UTC) + ctx = ctx.WithBlockTime(startTime) + blockTimeIncrement := time.Hour + + // Set the unbonding time to 1 day + unbondingPeriod := time.Hour * 24 + s.stakingKeeper.EXPECT().GetParams(mock.Anything).Return(stakingtypes.Params{UnbondingTime: unbondingPeriod}, nil) + + for timeIndex := 0; timeIndex <= 4; timeIndex++ { + for _, address := range addressesByTime[timeIndex] { + _, err := keeper.QueueTokenizeSharesAuthorization(ctx, address) + require.NoError(err) + } + ctx = ctx.WithBlockTime(ctx.BlockTime().Add(blockTimeIncrement)) + } + + // We'll unlock the tokens using the following progression + // The "alias'"/keys for these times assume a starting point of the Time 0 + // from above, plus the Unbonding Time + // Time -1 (2023-01-01 23:59:99): [] + // Time 0 (2023-01-02 00:00:00): [address0] + // Time 1 (2023-01-02 00:01:00): [] + // Time 2.5 (2023-01-02 00:02:30): [address1, address2, address3] + // Time 10 (2023-01-02 00:10:00): [address4, address5, address6] + unlockBlockTimes := map[string]time.Time{ + "-1": startTime.Add(unbondingPeriod).Add(-time.Second), + "0": startTime.Add(unbondingPeriod), + "1": startTime.Add(unbondingPeriod).Add(blockTimeIncrement), + "2.5": startTime.Add(unbondingPeriod).Add(2 * blockTimeIncrement).Add(blockTimeIncrement / 2), + "10": startTime.Add(unbondingPeriod).Add(10 * blockTimeIncrement), + } + expectedUnlockedAddresses := map[string][]string{ + "-1": {}, + "0": {addresses[0].String()}, + "1": {}, + "2.5": {addresses[1].String(), addresses[2].String(), addresses[3].String()}, + "10": {addresses[4].String(), addresses[5].String(), addresses[6].String()}, + } + + // Now we'll remove items from the queue sequentially + // First check with a block time before the first expiration - it should remove no addresses + actualAddresses, err := keeper.RemoveExpiredTokenizeShareLocks(ctx, unlockBlockTimes["-1"]) + require.NoError(err) + require.Equal(expectedUnlockedAddresses["-1"], actualAddresses, "no addresses unlocked from time -1") + + // Then pass in (time 0 + unbonding time) - it should remove the first address + actualAddresses, err = keeper.RemoveExpiredTokenizeShareLocks(ctx, unlockBlockTimes["0"]) + require.NoError(err) + require.Equal(expectedUnlockedAddresses["0"], actualAddresses, "one address unlocked from time 0") + + // Now pass in (time 1 + unbonding time) - it should remove no addresses since + // the address at time 0 was already removed + actualAddresses, err = keeper.RemoveExpiredTokenizeShareLocks(ctx, unlockBlockTimes["1"]) + require.NoError(err) + require.Equal(expectedUnlockedAddresses["1"], actualAddresses, "no addresses unlocked from time 1") + + // Now pass in (time 2.5 + unbonding time) - it should remove the three addresses from time 2 + actualAddresses, err = keeper.RemoveExpiredTokenizeShareLocks(ctx, unlockBlockTimes["2.5"]) + require.NoError(err) + require.Equal(expectedUnlockedAddresses["2.5"], actualAddresses, "addresses unlocked from time 2.5") + + // Finally pass in a block time far in the future, which should remove all the remaining locks + actualAddresses, err = keeper.RemoveExpiredTokenizeShareLocks(ctx, unlockBlockTimes["10"]) + require.NoError(err) + require.Equal(expectedUnlockedAddresses["10"], actualAddresses, "addresses unlocked from time 10") +} + +// Tests DelegatorIsLiquidStaker +func (s *KeeperTestSuite) TestDelegatorIsLiquidStaker() { + _, keeper := s.ctx, s.lsmKeeper + require := s.Require() + + // Create base and ICA accounts + baseAccountAddress := sdk.AccAddress("base-account") + icaAccountAddress := sdk.AccAddress( + address.Derive(authtypes.NewModuleAddress("icahost"), []byte("connection-0"+"icahost")), + ) + + // Only the ICA module account should be considered a liquid staking provider + require.False(keeper.DelegatorIsLiquidStaker(baseAccountAddress), "base account") + require.True(keeper.DelegatorIsLiquidStaker(icaAccountAddress), "ICA module account") +} + +func (s *KeeperTestSuite) TestCheckVestedDelegationInVestingAccount() { + var ( + vestingAcct *vestingtypes.ContinuousVestingAccount + startTime = time.Now() + endTime = startTime.Add(24 * time.Hour) + originalVesting = sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, math.NewInt(100_000))) + ) + require := s.Require() + + testCases := []struct { + name string + setupAcct func() + blockTime time.Time + coinRequired sdk.Coin + expRes bool + }{ + { + name: "vesting account has zero delegations", + setupAcct: func() {}, + blockTime: endTime, + coinRequired: sdk.NewCoin(sdk.DefaultBondDenom, math.OneInt()), + expRes: false, + }, + { + name: "vested delegations exist but for a different coin", + setupAcct: func() { + vestingAcct.DelegatedFree = sdk.NewCoins(sdk.NewCoin("uatom", math.NewInt(100_000))) + }, + blockTime: endTime, + coinRequired: sdk.NewCoin(sdk.DefaultBondDenom, math.OneInt()), + expRes: false, + }, + { + name: "all delegations are vesting", + setupAcct: func() { + vestingAcct.DelegatedVesting = vestingAcct.OriginalVesting + }, + blockTime: startTime, + coinRequired: sdk.NewCoin(sdk.DefaultBondDenom, math.OneInt()), + expRes: false, + }, + { + name: "not enough vested coin", + setupAcct: func() { + vestingAcct.DelegatedFree = sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, math.NewInt(80_000))) + }, + blockTime: endTime, + coinRequired: sdk.NewCoin(sdk.DefaultBondDenom, math.NewInt(100_000)), + expRes: false, + }, + { + name: "account is vested and have vested delegations", + setupAcct: func() { + vestingAcct.DelegatedFree = vestingAcct.OriginalVesting + }, + blockTime: endTime, + coinRequired: sdk.NewCoin(sdk.DefaultBondDenom, math.NewInt(100_000)), + expRes: true, + }, + { + name: "vesting account partially vested and have vesting and vested delegations", + setupAcct: func() { + vestingAcct.DelegatedFree = sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, math.NewInt(50_000))) + vestingAcct.DelegatedVesting = sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, math.NewInt(50_000))) + }, + blockTime: startTime.Add(18 * time.Hour), // vest 3/4 vesting period + coinRequired: sdk.NewCoin(sdk.DefaultBondDenom, math.NewInt(75_000)), + + expRes: true, + }, + } + + for _, tc := range testCases { + s.Run(tc.name, func() { + pubKey := secp256k1.GenPrivKey().PubKey() + baseAcc := authtypes.NewBaseAccount(sdk.AccAddress(pubKey.Address()), pubKey, 0, 0) + + var err error + vestingAcct, err = vestingtypes.NewContinuousVestingAccount( + baseAcc, + originalVesting, + startTime.Unix(), + endTime.Unix(), + ) + require.NoError(err) + + tc.setupAcct() + + require.Equal( + tc.expRes, lsmkeeper.CheckVestedDelegationInVestingAccount( + vestingAcct, + tc.blockTime, + tc.coinRequired, + ), + ) + }) + } +} diff --git a/x/liquid/keeper/msg_server.go b/x/liquid/keeper/msg_server.go new file mode 100644 index 00000000..ebe7352b --- /dev/null +++ b/x/liquid/keeper/msg_server.go @@ -0,0 +1,513 @@ +package keeper + +import ( + "context" + "errors" + "fmt" + + errorsmod "cosmossdk.io/errors" + "cosmossdk.io/math" + + sdk "github.com/cosmos/cosmos-sdk/types" + sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + vesting "github.com/cosmos/cosmos-sdk/x/auth/vesting/exported" + govtypes "github.com/cosmos/cosmos-sdk/x/gov/types" + minttypes "github.com/cosmos/cosmos-sdk/x/mint/types" + stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" + + "github.com/KYVENetwork/chain/x/liquid/types" +) + +type msgServer struct { + *Keeper +} + +// NewMsgServerImpl returns an implementation of the staking MsgServer interface +// for the provided Keeper. +func NewMsgServerImpl(keeper *Keeper) types.MsgServer { + return &msgServer{Keeper: keeper} +} + +var _ types.MsgServer = msgServer{} + +// UpdateParams defines a method to perform updating of params for the x/liquid module. +func (k msgServer) UpdateParams(ctx context.Context, msg *types.MsgUpdateParams) (*types.MsgUpdateParamsResponse, error) { + if k.authority != msg.Authority { + return nil, errorsmod.Wrapf(govtypes.ErrInvalidSigner, "invalid authority; expected %s, got %s", k.authority, msg.Authority) + } + + if err := msg.Params.Validate(); err != nil { + return nil, err + } + + // store params + if err := k.SetParams(ctx, msg.Params); err != nil { + return nil, err + } + + return &types.MsgUpdateParamsResponse{}, nil +} + +// Tokenizes shares associated with a delegation by creating a tokenize share record +// and returning tokens with a denom of the format {validatorAddress}/{recordId} +func (k msgServer) TokenizeShares(goCtx context.Context, msg *types.MsgTokenizeShares) (*types.MsgTokenizeSharesResponse, error) { + ctx := sdk.UnwrapSDKContext(goCtx) + + valAddr, valErr := k.stakingKeeper.ValidatorAddressCodec().StringToBytes(msg.ValidatorAddress) + if valErr != nil { + return nil, valErr + } + validator, err := k.stakingKeeper.GetValidator(ctx, valAddr) + if err != nil { + return nil, err + } + + delegatorAddress, err := k.authKeeper.AddressCodec().StringToBytes(msg.DelegatorAddress) + if err != nil { + return nil, err + } + + _, err = k.authKeeper.AddressCodec().StringToBytes(msg.TokenizedShareOwner) + if err != nil { + return nil, err + } + + if !msg.Amount.IsValid() || !msg.Amount.Amount.IsPositive() { + return nil, errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "invalid shares amount") + } + + // Check if the delegator has disabled tokenization + lockStatus, unlockTime := k.GetTokenizeSharesLock(ctx, delegatorAddress) + if lockStatus == types.TOKENIZE_SHARE_LOCK_STATUS_LOCKED { + return nil, types.ErrTokenizeSharesDisabledForAccount + } + if lockStatus == types.TOKENIZE_SHARE_LOCK_STATUS_LOCK_EXPIRING { + return nil, types.ErrTokenizeSharesDisabledForAccount.Wrapf("tokenization will be allowed at %s", unlockTime) + } + + bondDenom, err := k.stakingKeeper.BondDenom(ctx) + if err != nil { + return nil, err + } + + if msg.Amount.Denom != bondDenom { + return nil, types.ErrOnlyBondDenomAllowdForTokenize + } + + acc := k.authKeeper.GetAccount(ctx, delegatorAddress) + if acc != nil { + acc, ok := acc.(vesting.VestingAccount) + if ok { + // if account is a vesting account, it checks if free delegation (non-vesting delegation) is not exceeding + // the tokenize share amount and execute further tokenize share process + // tokenize share is reducing unlocked tokens delegation from the vesting account and further process + // is not causing issues + if !CheckVestedDelegationInVestingAccount(acc, ctx.BlockTime(), msg.Amount) { + return nil, types.ErrExceedingFreeVestingDelegations + } + } + } + + shares, err := k.stakingKeeper.ValidateUnbondAmount( + ctx, delegatorAddress, valAddr, msg.Amount.Amount, + ) + if err != nil { + return nil, err + } + + // sanity check to avoid creating a tokenized share record with zero shares + if shares.IsZero() { + return nil, errorsmod.Wrap(types.ErrInsufficientShares, "cannot tokenize zero shares") + } + + // Check that the delegator has no ongoing redelegations to the validator + found, err := k.stakingKeeper.HasReceivingRedelegation(ctx, delegatorAddress, valAddr) + if err != nil { + return nil, err + } + if found { + return nil, types.ErrRedelegationInProgress + } + + if err := k.SafelyIncreaseTotalLiquidStakedTokens(ctx, msg.Amount.Amount, true); err != nil { + return nil, err + } + _, err = k.SafelyIncreaseValidatorLiquidShares(ctx, valAddr, shares, true) + if err != nil { + return nil, err + } + + recordID := k.GetLastTokenizeShareRecordID(ctx) + 1 + k.SetLastTokenizeShareRecordID(ctx, recordID) + + record := types.TokenizeShareRecord{ + Id: recordID, + Owner: msg.TokenizedShareOwner, + ModuleAccount: fmt.Sprintf("%s%d", types.TokenizeShareModuleAccountPrefix, recordID), + Validator: msg.ValidatorAddress, + } + + // note: this returnAmount can be slightly off from the original delegation amount if there + // is a decimal to int precision error + returnAmount, err := k.stakingKeeper.Unbond(ctx, delegatorAddress, valAddr, shares) + if err != nil { + return nil, err + } + + if validator.IsBonded() { + coins := sdk.NewCoins(sdk.NewCoin(bondDenom, returnAmount)) + err := k.bankKeeper.SendCoinsFromModuleToModule(ctx, stakingtypes.BondedPoolName, stakingtypes.NotBondedPoolName, coins) + if err != nil { + return nil, err + } + } + + // Note: UndelegateCoinsFromModuleToAccount is internally calling TrackUndelegation for vesting account + returnCoin := sdk.NewCoin(bondDenom, returnAmount) + err = k.bankKeeper.UndelegateCoinsFromModuleToAccount(ctx, stakingtypes.NotBondedPoolName, delegatorAddress, + sdk.Coins{returnCoin}) + if err != nil { + return nil, err + } + + // Re-calculate the shares in case there was rounding precision during the undelegation + newShares, err := validator.SharesFromTokens(returnAmount) + if err != nil { + return nil, err + } + + // The share tokens returned maps 1:1 with shares + shareToken := sdk.NewCoin(record.GetShareTokenDenom(), newShares.TruncateInt()) + + err = k.bankKeeper.MintCoins(ctx, minttypes.ModuleName, sdk.Coins{shareToken}) + if err != nil { + return nil, err + } + + err = k.bankKeeper.SendCoinsFromModuleToAccount(ctx, minttypes.ModuleName, delegatorAddress, sdk.Coins{shareToken}) + if err != nil { + return nil, err + } + + // create reward ownership record + err = k.AddTokenizeShareRecord(ctx, record) + if err != nil { + return nil, err + } + // send coins to module account + err = k.bankKeeper.SendCoins(ctx, delegatorAddress, record.GetModuleAddress(), sdk.Coins{returnCoin}) + if err != nil { + return nil, err + } + + // Note: it is needed to get latest validator object to get Keeper.Delegate function work properly + validator, err = k.stakingKeeper.GetValidator(ctx, valAddr) + if err != nil { + return nil, err + } + + // delegate from module account + _, err = k.stakingKeeper.Delegate(ctx, record.GetModuleAddress(), returnAmount, stakingtypes.Unbonded, validator, + true) + if err != nil { + return nil, err + } + + ctx.EventManager().EmitEvent( + sdk.NewEvent( + types.EventTypeTokenizeShares, + sdk.NewAttribute(types.AttributeKeyDelegator, msg.DelegatorAddress), + sdk.NewAttribute(types.AttributeKeyValidator, msg.ValidatorAddress), + sdk.NewAttribute(types.AttributeKeyShareOwner, msg.TokenizedShareOwner), + sdk.NewAttribute(types.AttributeKeyShareRecordID, fmt.Sprintf("%d", record.Id)), + sdk.NewAttribute(types.AttributeKeyAmount, msg.Amount.String()), + sdk.NewAttribute(types.AttributeKeyTokenizedShares, shareToken.String()), + ), + ) + + return &types.MsgTokenizeSharesResponse{ + Amount: shareToken, + }, nil +} + +// Converts tokenized shares back into a native delegation +func (k msgServer) RedeemTokensForShares(goCtx context.Context, msg *types.MsgRedeemTokensForShares) (*types.MsgRedeemTokensForSharesResponse, error) { + ctx := sdk.UnwrapSDKContext(goCtx) + + delegatorAddress, err := k.authKeeper.AddressCodec().StringToBytes(msg.DelegatorAddress) + if err != nil { + return nil, err + } + + if !msg.Amount.IsValid() || !msg.Amount.Amount.IsPositive() { + return nil, errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "invalid shares amount") + } + + shareToken := msg.Amount + balance := k.bankKeeper.GetBalance(ctx, delegatorAddress, shareToken.Denom) + if balance.Amount.LT(shareToken.Amount) { + return nil, types.ErrNotEnoughBalance + } + + record, err := k.GetTokenizeShareRecordByDenom(ctx, shareToken.Denom) + if err != nil { + return nil, err + } + + valAddr, valErr := k.stakingKeeper.ValidatorAddressCodec().StringToBytes(record.Validator) + if valErr != nil { + return nil, valErr + } + + validator, err := k.stakingKeeper.GetValidator(ctx, valAddr) + if err != nil { + return nil, err + } + + delegation, err := k.stakingKeeper.GetDelegation(ctx, record.GetModuleAddress(), valAddr) + if err != nil { + return nil, err + } + + // Similar to undelegations, if the account is attempting to tokenize the full delegation, + // but there's a precision error due to the decimal to int conversion, round up to the + // full decimal amount before modifying the delegation + shares := math.LegacyNewDecFromInt(shareToken.Amount) + if shareToken.Amount.Equal(delegation.Shares.TruncateInt()) { + shares = delegation.Shares + } + tokens := validator.TokensFromShares(shares).TruncateInt() + + // prevent redemption that returns a 0 amount + if tokens.IsZero() { + return nil, types.ErrTinyRedemptionAmount + } + + if err := k.DecreaseTotalLiquidStakedTokens(ctx, tokens); err != nil { + return nil, err + } + _, err = k.DecreaseValidatorLiquidShares(ctx, valAddr, shares) + if err != nil { + return nil, err + } + + returnAmount, err := k.stakingKeeper.Unbond(ctx, record.GetModuleAddress(), valAddr, shares) + if err != nil { + return nil, err + } + + if validator.IsBonded() { + bondDenom, err := k.stakingKeeper.BondDenom(ctx) + if err != nil { + return nil, err + } + + coins := sdk.NewCoins(sdk.NewCoin(bondDenom, returnAmount)) + err = k.bankKeeper.SendCoinsFromModuleToModule(ctx, stakingtypes.BondedPoolName, stakingtypes.NotBondedPoolName, coins) + if err != nil { + return nil, err + } + } + + // Note: since delegation object has been changed from unbond call, it gets latest delegation + _, err = k.stakingKeeper.GetDelegation(ctx, record.GetModuleAddress(), valAddr) + if err != nil && !errors.Is(err, stakingtypes.ErrNoDelegation) { + return nil, err + } + + // this err will be ErrNoDelegation + if err != nil { + if err := k.WithdrawSingleShareRecordReward(ctx, record.Id); err != nil { + return nil, err + } + err = k.DeleteTokenizeShareRecord(ctx, record.Id) + if err != nil { + return nil, err + } + } + + // send share tokens to NotBondedPool and burn + err = k.bankKeeper.SendCoinsFromAccountToModule(ctx, delegatorAddress, stakingtypes.NotBondedPoolName, + sdk.Coins{shareToken}) + if err != nil { + return nil, err + } + err = k.bankKeeper.BurnCoins(ctx, stakingtypes.NotBondedPoolName, sdk.Coins{shareToken}) + if err != nil { + return nil, err + } + + bondDenom, err := k.stakingKeeper.BondDenom(ctx) + if err != nil { + return nil, err + } + // send equivalent amount of tokens to the delegator + returnCoin := sdk.NewCoin(bondDenom, returnAmount) + err = k.bankKeeper.SendCoinsFromModuleToAccount(ctx, stakingtypes.NotBondedPoolName, delegatorAddress, + sdk.Coins{returnCoin}) + if err != nil { + return nil, err + } + + // Note: it is needed to get latest validator object to get Keeper.Delegate function work properly + validator, err = k.stakingKeeper.GetValidator(ctx, valAddr) + if err != nil { + return nil, err + } + + // convert the share tokens to delegated status + // Note: Delegate(substractAccount => true) -> DelegateCoinsFromAccountToModule -> TrackDelegation for vesting account + _, err = k.stakingKeeper.Delegate(ctx, delegatorAddress, returnAmount, stakingtypes.Unbonded, validator, true) + if err != nil { + return nil, err + } + + ctx.EventManager().EmitEvent( + sdk.NewEvent( + types.EventTypeRedeemShares, + sdk.NewAttribute(types.AttributeKeyDelegator, msg.DelegatorAddress), + sdk.NewAttribute(types.AttributeKeyValidator, validator.OperatorAddress), + sdk.NewAttribute(types.AttributeKeyAmount, shareToken.String()), + ), + ) + + return &types.MsgRedeemTokensForSharesResponse{ + Amount: returnCoin, + }, nil +} + +// Transfers the ownership of rewards associated with a tokenize share record +func (k msgServer) TransferTokenizeShareRecord(goCtx context.Context, msg *types.MsgTransferTokenizeShareRecord) (*types.MsgTransferTokenizeShareRecordResponse, error) { + ctx := sdk.UnwrapSDKContext(goCtx) + + record, err := k.GetTokenizeShareRecord(ctx, msg.TokenizeShareRecordId) + if err != nil { + return nil, types.ErrTokenizeShareRecordNotExists + } + + if record.Owner != msg.Sender { + return nil, types.ErrNotTokenizeShareRecordOwner + } + + // Remove old account reference + oldOwner, err := k.authKeeper.AddressCodec().StringToBytes(record.Owner) + if err != nil { + return nil, sdkerrors.ErrInvalidAddress + } + newOwner, err := k.authKeeper.AddressCodec().StringToBytes(msg.NewOwner) + if err != nil { + return nil, sdkerrors.ErrInvalidAddress + } + + // This check is necessary to prevent sending rewards to a blocked addresses + if k.bankKeeper.BlockedAddr(oldOwner) { + return nil, errorsmod.Wrapf(sdkerrors.ErrUnauthorized, "%s is not allowed to receive funds", record.Owner) + } + if k.bankKeeper.BlockedAddr(newOwner) { + return nil, errorsmod.Wrapf(sdkerrors.ErrUnauthorized, "%s is not allowed to receive funds", msg.NewOwner) + } + + k.deleteTokenizeShareRecordWithOwner(ctx, oldOwner, record.Id) + record.Owner = msg.NewOwner + k.setTokenizeShareRecord(ctx, record) + + // Set new account reference + k.setTokenizeShareRecordWithOwner(ctx, newOwner, record.Id) + + ctx.EventManager().EmitEvent( + sdk.NewEvent( + types.EventTypeTransferTokenizeShareRecord, + sdk.NewAttribute(types.AttributeKeyShareRecordID, fmt.Sprintf("%d", msg.TokenizeShareRecordId)), + sdk.NewAttribute(sdk.AttributeKeySender, msg.Sender), + sdk.NewAttribute(types.AttributeKeyShareOwner, msg.NewOwner), + ), + ) + + return &types.MsgTransferTokenizeShareRecordResponse{}, nil +} + +// DisableTokenizeShares prevents an address from tokenizing any of their delegations +func (k msgServer) DisableTokenizeShares(ctx context.Context, msg *types.MsgDisableTokenizeShares) (*types.MsgDisableTokenizeSharesResponse, error) { + delegator, err := k.authKeeper.AddressCodec().StringToBytes(msg.DelegatorAddress) + if err != nil { + panic(err) + } + + // If tokenized shares is already disabled, alert the user + lockStatus, completionTime := k.GetTokenizeSharesLock(ctx, delegator) + if lockStatus == types.TOKENIZE_SHARE_LOCK_STATUS_LOCKED { + return nil, types.ErrTokenizeSharesAlreadyDisabledForAccount + } + + // If the tokenized shares lock is expiring, remove the pending unlock from the queue + if lockStatus == types.TOKENIZE_SHARE_LOCK_STATUS_LOCK_EXPIRING { + k.CancelTokenizeShareLockExpiration(ctx, delegator, completionTime) + } + + // Create a new tokenization lock for the user + // Note: if there is a lock expiration in progress, this will override the expiration + k.AddTokenizeSharesLock(ctx, delegator) + + return &types.MsgDisableTokenizeSharesResponse{}, nil +} + +// EnableTokenizeShares begins the countdown after which tokenizing shares by the +// sender address is re-allowed, which will complete after the unbonding period +func (k msgServer) EnableTokenizeShares(ctx context.Context, msg *types.MsgEnableTokenizeShares) (*types.MsgEnableTokenizeSharesResponse, error) { + delegator, err := k.authKeeper.AddressCodec().StringToBytes(msg.DelegatorAddress) + if err != nil { + panic(err) + } + + // If tokenized shares aren't current disabled, alert the user + lockStatus, unlockTime := k.GetTokenizeSharesLock(ctx, delegator) + if lockStatus == types.TOKENIZE_SHARE_LOCK_STATUS_UNLOCKED { + return nil, types.ErrTokenizeSharesAlreadyEnabledForAccount + } + if lockStatus == types.TOKENIZE_SHARE_LOCK_STATUS_LOCK_EXPIRING { + return nil, types.ErrTokenizeSharesAlreadyEnabledForAccount.Wrapf( + "tokenize shares re-enablement already in progress, ending at %s", unlockTime) + } + + // Otherwise queue the unlock + completionTime, err := k.QueueTokenizeSharesAuthorization(ctx, delegator) + if err != nil { + panic(err) + } + + return &types.MsgEnableTokenizeSharesResponse{CompletionTime: completionTime}, nil +} + +// WithdrawTokenizeShareRecordReward defines a method to withdraw reward for owning TokenizeShareRecord +func (k msgServer) WithdrawTokenizeShareRecordReward(goCtx context.Context, msg *types.MsgWithdrawTokenizeShareRecordReward) (*types.MsgWithdrawTokenizeShareRecordRewardResponse, error) { + ctx := sdk.UnwrapSDKContext(goCtx) + + ownerAddr, err := k.authKeeper.AddressCodec().StringToBytes(msg.OwnerAddress) + if err != nil { + return nil, err + } + + _, err = k.Keeper.WithdrawTokenizeShareRecordReward(ctx, ownerAddr, msg.RecordId) + if err != nil { + return nil, err + } + + return &types.MsgWithdrawTokenizeShareRecordRewardResponse{}, nil +} + +// WithdrawAllTokenizeShareRecordReward defines a method to withdraw reward for owning TokenizeShareRecord +func (k msgServer) WithdrawAllTokenizeShareRecordReward(goCtx context.Context, msg *types.MsgWithdrawAllTokenizeShareRecordReward) (*types.MsgWithdrawAllTokenizeShareRecordRewardResponse, error) { + ctx := sdk.UnwrapSDKContext(goCtx) + + ownerAddr, err := k.authKeeper.AddressCodec().StringToBytes(msg.OwnerAddress) + if err != nil { + return nil, err + } + + _, err = k.Keeper.WithdrawAllTokenizeShareRecordReward(ctx, ownerAddr) + if err != nil { + return nil, err + } + + return &types.MsgWithdrawAllTokenizeShareRecordRewardResponse{}, nil +} diff --git a/x/liquid/keeper/params.go b/x/liquid/keeper/params.go new file mode 100644 index 00000000..44f82004 --- /dev/null +++ b/x/liquid/keeper/params.go @@ -0,0 +1,48 @@ +package keeper + +import ( + "context" + + "cosmossdk.io/math" + + "github.com/KYVENetwork/chain/x/liquid/types" +) + +// SetParams sets the x/liquid module parameters. +// CONTRACT: This method performs no validation of the parameters. +func (k Keeper) SetParams(ctx context.Context, params types.Params) error { + store := k.storeService.OpenKVStore(ctx) + bz, err := k.cdc.Marshal(¶ms) + if err != nil { + return err + } + return store.Set(types.ParamsKey, bz) +} + +// GetParams gets the x/liquid module parameters. +func (k Keeper) GetParams(ctx context.Context) (params types.Params, err error) { + store := k.storeService.OpenKVStore(ctx) + bz, err := store.Get(types.ParamsKey) + if err != nil { + return params, err + } + + if bz == nil { + return types.DefaultParams(), nil + } + + err = k.cdc.Unmarshal(bz, ¶ms) + return params, err +} + +// Global liquid staking cap across all liquid staking providers +func (k Keeper) GlobalLiquidStakingCap(ctx context.Context) (math.LegacyDec, error) { + params, err := k.GetParams(ctx) + return params.GlobalLiquidStakingCap, err +} + +// Liquid staking cap for each validator +func (k Keeper) ValidatorLiquidStakingCap(ctx context.Context) (math.LegacyDec, error) { + params, err := k.GetParams(ctx) + return params.ValidatorLiquidStakingCap, err +} diff --git a/x/liquid/keeper/tokenize_share_record.go b/x/liquid/keeper/tokenize_share_record.go new file mode 100644 index 00000000..974f0c53 --- /dev/null +++ b/x/liquid/keeper/tokenize_share_record.go @@ -0,0 +1,196 @@ +package keeper + +import ( + "context" + "fmt" + + gogotypes "github.com/cosmos/gogoproto/types" + + errorsmod "cosmossdk.io/errors" + storetypes "cosmossdk.io/store/types" + + "github.com/cosmos/cosmos-sdk/runtime" + sdk "github.com/cosmos/cosmos-sdk/types" + + "github.com/KYVENetwork/chain/x/liquid/types" +) + +func (k Keeper) GetLastTokenizeShareRecordID(ctx context.Context) uint64 { + store := k.storeService.OpenKVStore(ctx) + bytes, err := store.Get(types.LastTokenizeShareRecordIDKey) + if err != nil { + panic(err) + } + + if bytes == nil { + return 0 + } + return sdk.BigEndianToUint64(bytes) +} + +func (k Keeper) SetLastTokenizeShareRecordID(ctx context.Context, id uint64) { + store := k.storeService.OpenKVStore(ctx) + err := store.Set(types.LastTokenizeShareRecordIDKey, sdk.Uint64ToBigEndian(id)) + if err != nil { + panic(err) + } +} + +func (k Keeper) GetTokenizeShareRecord(ctx context.Context, id uint64) (tokenizeShareRecord types.TokenizeShareRecord, err error) { + store := k.storeService.OpenKVStore(ctx) + + bz, err := store.Get(types.GetTokenizeShareRecordByIndexKey(id)) + if err != nil { + return tokenizeShareRecord, err + } + + if bz == nil { + return tokenizeShareRecord, errorsmod.Wrap(types.ErrTokenizeShareRecordNotExists, fmt.Sprintf("tokenizeShareRecord %d does not exist", id)) + } + + k.cdc.MustUnmarshal(bz, &tokenizeShareRecord) + return tokenizeShareRecord, nil +} + +func (k Keeper) GetTokenizeShareRecordsByOwner(ctx context.Context, owner sdk.AccAddress) (tokenizeShareRecords []types.TokenizeShareRecord) { + store := k.storeService.OpenKVStore(ctx) + + it := storetypes.KVStorePrefixIterator(runtime.KVStoreAdapter(store), types.GetTokenizeShareRecordIDsByOwnerPrefix(owner)) + defer it.Close() + + for ; it.Valid(); it.Next() { + var id gogotypes.UInt64Value + k.cdc.MustUnmarshal(it.Value(), &id) + + tokenizeShareRecord, err := k.GetTokenizeShareRecord(ctx, id.Value) + if err != nil { + continue + } + tokenizeShareRecords = append(tokenizeShareRecords, tokenizeShareRecord) + } + return +} + +func (k Keeper) GetTokenizeShareRecordByDenom(ctx context.Context, denom string) (types.TokenizeShareRecord, error) { + store := k.storeService.OpenKVStore(ctx) + bz, err := store.Get(types.GetTokenizeShareRecordIDByDenomKey(denom)) + if err != nil { + return types.TokenizeShareRecord{}, err + } + + if bz == nil { + return types.TokenizeShareRecord{}, fmt.Errorf("tokenize share record not found from denom: %s", denom) + } + + var id gogotypes.UInt64Value + k.cdc.MustUnmarshal(bz, &id) + + return k.GetTokenizeShareRecord(ctx, id.Value) +} + +func (k Keeper) GetAllTokenizeShareRecords(ctx context.Context) (tokenizeShareRecords []types.TokenizeShareRecord) { + store := k.storeService.OpenKVStore(ctx) + + it := storetypes.KVStorePrefixIterator(runtime.KVStoreAdapter(store), types.TokenizeShareRecordPrefix) + defer it.Close() + + for ; it.Valid(); it.Next() { + var tokenizeShareRecord types.TokenizeShareRecord + k.cdc.MustUnmarshal(it.Value(), &tokenizeShareRecord) + + tokenizeShareRecords = append(tokenizeShareRecords, tokenizeShareRecord) + } + return +} + +func (k Keeper) AddTokenizeShareRecord(ctx context.Context, tokenizeShareRecord types.TokenizeShareRecord) error { + hasRecord, err := k.hasTokenizeShareRecord(ctx, tokenizeShareRecord.Id) + if err != nil { + return err + } + + if hasRecord { + return errorsmod.Wrapf(types.ErrTokenizeShareRecordAlreadyExists, "TokenizeShareRecord already exists: %d", tokenizeShareRecord.Id) + } + + k.setTokenizeShareRecord(ctx, tokenizeShareRecord) + + owner, err := k.authKeeper.AddressCodec().StringToBytes(tokenizeShareRecord.Owner) + if err != nil { + return err + } + + k.setTokenizeShareRecordWithOwner(ctx, owner, tokenizeShareRecord.Id) + k.setTokenizeShareRecordWithDenom(ctx, tokenizeShareRecord.GetShareTokenDenom(), tokenizeShareRecord.Id) + + return nil +} + +func (k Keeper) DeleteTokenizeShareRecord(ctx context.Context, recordID uint64) error { + record, err := k.GetTokenizeShareRecord(ctx, recordID) + if err != nil { + return err + } + owner, err := k.authKeeper.AddressCodec().StringToBytes(record.Owner) + if err != nil { + return err + } + + store := k.storeService.OpenKVStore(ctx) + err = store.Delete(types.GetTokenizeShareRecordByIndexKey(recordID)) + if err != nil { + return err + } + err = store.Delete(types.GetTokenizeShareRecordIDByOwnerAndIDKey(owner, recordID)) + if err != nil { + return err + } + err = store.Delete(types.GetTokenizeShareRecordIDByDenomKey(record.GetShareTokenDenom())) + if err != nil { + return err + } + return nil +} + +func (k Keeper) hasTokenizeShareRecord(ctx context.Context, id uint64) (bool, error) { + store := k.storeService.OpenKVStore(ctx) + return store.Has(types.GetTokenizeShareRecordByIndexKey(id)) +} + +func (k Keeper) setTokenizeShareRecord(ctx context.Context, tokenizeShareRecord types.TokenizeShareRecord) { + store := k.storeService.OpenKVStore(ctx) + bz := k.cdc.MustMarshal(&tokenizeShareRecord) + + err := store.Set(types.GetTokenizeShareRecordByIndexKey(tokenizeShareRecord.Id), bz) + if err != nil { + panic(err) + } +} + +func (k Keeper) setTokenizeShareRecordWithOwner(ctx context.Context, owner sdk.AccAddress, id uint64) { + store := k.storeService.OpenKVStore(ctx) + bz := k.cdc.MustMarshal(&gogotypes.UInt64Value{Value: id}) + + err := store.Set(types.GetTokenizeShareRecordIDByOwnerAndIDKey(owner, id), bz) + if err != nil { + panic(err) + } +} + +func (k Keeper) deleteTokenizeShareRecordWithOwner(ctx context.Context, owner sdk.AccAddress, id uint64) { + store := k.storeService.OpenKVStore(ctx) + err := store.Delete(types.GetTokenizeShareRecordIDByOwnerAndIDKey(owner, id)) + if err != nil { + panic(err) + } +} + +func (k Keeper) setTokenizeShareRecordWithDenom(ctx context.Context, denom string, id uint64) { + store := k.storeService.OpenKVStore(ctx) + bz := k.cdc.MustMarshal(&gogotypes.UInt64Value{Value: id}) + + err := store.Set(types.GetTokenizeShareRecordIDByDenomKey(denom), bz) + if err != nil { + panic(err) + } +} diff --git a/x/liquid/keeper/tokenize_share_record_test.go b/x/liquid/keeper/tokenize_share_record_test.go new file mode 100644 index 00000000..e63dd18a --- /dev/null +++ b/x/liquid/keeper/tokenize_share_record_test.go @@ -0,0 +1,64 @@ +package keeper_test + +import ( + simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims" + + "github.com/KYVENetwork/chain/x/liquid/types" +) + +func (suite *KeeperTestSuite) TestGetLastTokenizeShareRecordId() { + ctx, keeper := suite.ctx, suite.lsmKeeper + lastTokenizeShareRecordID := keeper.GetLastTokenizeShareRecordID(ctx) + suite.Equal(lastTokenizeShareRecordID, uint64(0)) + keeper.SetLastTokenizeShareRecordID(ctx, 100) + lastTokenizeShareRecordID = keeper.GetLastTokenizeShareRecordID(ctx) + suite.Equal(lastTokenizeShareRecordID, uint64(100)) +} + +func (suite *KeeperTestSuite) TestGetTokenizeShareRecord() { + ctx, keeper := suite.ctx, suite.lsmKeeper + addrs := simtestutil.CreateIncrementalAccounts(2) + + owner1, owner2 := addrs[0], addrs[1] + tokenizeShareRecord1 := types.TokenizeShareRecord{ + Id: 0, + Owner: owner1.String(), + ModuleAccount: "test-module-account-1", + Validator: "test-validator", + } + tokenizeShareRecord2 := types.TokenizeShareRecord{ + Id: 1, + Owner: owner2.String(), + ModuleAccount: "test-module-account-2", + Validator: "test-validator", + } + tokenizeShareRecord3 := types.TokenizeShareRecord{ + Id: 2, + Owner: owner1.String(), + ModuleAccount: "test-module-account-3", + Validator: "test-validator", + } + err := keeper.AddTokenizeShareRecord(ctx, tokenizeShareRecord1) + suite.NoError(err) + err = keeper.AddTokenizeShareRecord(ctx, tokenizeShareRecord2) + suite.NoError(err) + err = keeper.AddTokenizeShareRecord(ctx, tokenizeShareRecord3) + suite.NoError(err) + + tokenizeShareRecord, err := keeper.GetTokenizeShareRecord(ctx, 2) + suite.NoError(err) + suite.Equal(tokenizeShareRecord, tokenizeShareRecord3) + + tokenizeShareRecord, err = keeper.GetTokenizeShareRecordByDenom(ctx, tokenizeShareRecord2.GetShareTokenDenom()) + suite.NoError(err) + suite.Equal(tokenizeShareRecord, tokenizeShareRecord2) + + tokenizeShareRecords := keeper.GetAllTokenizeShareRecords(ctx) + suite.Equal(len(tokenizeShareRecords), 3) + + tokenizeShareRecords = keeper.GetTokenizeShareRecordsByOwner(ctx, owner1) + suite.Equal(len(tokenizeShareRecords), 2) + + tokenizeShareRecords = keeper.GetTokenizeShareRecordsByOwner(ctx, owner2) + suite.Equal(len(tokenizeShareRecords), 1) +} diff --git a/x/liquid/module.go b/x/liquid/module.go new file mode 100644 index 00000000..8136537b --- /dev/null +++ b/x/liquid/module.go @@ -0,0 +1,217 @@ +package liquid + +import ( + "context" + "cosmossdk.io/core/store" + "cosmossdk.io/depinject" + "encoding/json" + "fmt" + authKeeper "github.com/cosmos/cosmos-sdk/x/auth/keeper" + authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" + bankKeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper" + distributionKeeper "github.com/cosmos/cosmos-sdk/x/distribution/keeper" + stakingKeeper "github.com/cosmos/cosmos-sdk/x/staking/keeper" + + gwruntime "github.com/grpc-ecosystem/grpc-gateway/runtime" + "github.com/spf13/cobra" + + "cosmossdk.io/core/appmodule" + + "cosmossdk.io/log" + + "github.com/cosmos/cosmos-sdk/client" + "github.com/cosmos/cosmos-sdk/codec" + cdctypes "github.com/cosmos/cosmos-sdk/codec/types" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/types/module" + + "github.com/KYVENetwork/chain/x/liquid/client/cli" + "github.com/KYVENetwork/chain/x/liquid/keeper" + "github.com/KYVENetwork/chain/x/liquid/types" + + modulev1 "github.com/KYVENetwork/chain/api/kyve/liquid/module/v1" +) + +const ( + consensusVersion uint64 = 1 +) + +var ( + _ module.AppModuleBasic = AppModuleBasic{} + _ module.HasServices = AppModule{} + _ module.HasGenesis = AppModule{} + + _ appmodule.AppModule = AppModule{} + _ appmodule.HasBeginBlocker = AppModule{} +) + +// AppModuleBasic defines the basic application module used by the liquid module. +type AppModuleBasic struct { + cdc codec.Codec + ak types.AccountKeeper +} + +// Name returns the liquid module's name. +func (AppModuleBasic) Name() string { + return types.ModuleName +} + +// RegisterLegacyAminoCodec registers the liquid module's types on the given LegacyAmino codec. +func (AppModuleBasic) RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) { + types.RegisterLegacyAminoCodec(cdc) +} + +// RegisterInterfaces registers the module's interface types +func (AppModuleBasic) RegisterInterfaces(registry cdctypes.InterfaceRegistry) { + types.RegisterInterfaces(registry) +} + +// DefaultGenesis returns default genesis state as raw bytes for the liquid +// module. +func (AppModuleBasic) DefaultGenesis(cdc codec.JSONCodec) json.RawMessage { + return cdc.MustMarshalJSON(types.DefaultGenesisState()) +} + +// ValidateGenesis performs genesis state validation for the liquid module. +func (AppModuleBasic) ValidateGenesis(cdc codec.JSONCodec, config client.TxEncodingConfig, bz json.RawMessage) error { + var data types.GenesisState + if err := cdc.UnmarshalJSON(bz, &data); err != nil { + return fmt.Errorf("failed to unmarshal %s genesis state: %w", types.ModuleName, err) + } + + return types.ValidateGenesis(&data) +} + +// RegisterGRPCGatewayRoutes registers the gRPC Gateway routes for the liquid module. +func (AppModuleBasic) RegisterGRPCGatewayRoutes(clientCtx client.Context, mux *gwruntime.ServeMux) { + if err := types.RegisterQueryHandlerClient(context.Background(), mux, types.NewQueryClient(clientCtx)); err != nil { + panic(err) + } +} + +// GetTxCmd returns the root tx command for the liquid module. +func (amb AppModuleBasic) GetTxCmd() *cobra.Command { + return cli.NewTxCmd(amb.cdc.InterfaceRegistry().SigningContext().ValidatorAddressCodec(), amb.cdc.InterfaceRegistry().SigningContext().AddressCodec()) +} + +// AppModule implements an application module for the liquid module. +type AppModule struct { + AppModuleBasic + + keeper *keeper.Keeper + accountKeeper types.AccountKeeper + bankKeeper types.BankKeeper + stakingKeeper types.StakingKeeper +} + +// BeginBlock returns the Begin Blocker for the liquid module. +func (am AppModule) BeginBlock(ctx context.Context) error { + return am.keeper.BeginBlocker(ctx) +} + +// NewAppModule creates a new AppModule object +func NewAppModule( + cdc codec.Codec, + keeper *keeper.Keeper, + ak types.AccountKeeper, + bk types.BankKeeper, + sk types.StakingKeeper, +) AppModule { + return AppModule{ + AppModuleBasic: AppModuleBasic{cdc: cdc, ak: ak}, + keeper: keeper, + accountKeeper: ak, + bankKeeper: bk, + stakingKeeper: sk, + } +} + +// IsOnePerModuleType implements the depinject.OnePerModuleType interface. +func (am AppModule) IsOnePerModuleType() {} + +// IsAppModule implements the appmodule.AppModule interface. +func (am AppModule) IsAppModule() {} + +// RegisterServices registers module services. +func (am AppModule) RegisterServices(cfg module.Configurator) { + types.RegisterMsgServer(cfg.MsgServer(), keeper.NewMsgServerImpl(am.keeper)) + querier := keeper.Querier{Keeper: am.keeper} + types.RegisterQueryServer(cfg.QueryServer(), querier) +} + +// InitGenesis performs genesis initialization for the liquid module. +func (am AppModule) InitGenesis(ctx sdk.Context, cdc codec.JSONCodec, data json.RawMessage) { + var genesisState types.GenesisState + + cdc.MustUnmarshalJSON(data, &genesisState) + + am.keeper.InitGenesis(ctx, &genesisState) +} + +// ExportGenesis returns the exported genesis state as raw bytes for the liquid +// module. +func (am AppModule) ExportGenesis(ctx sdk.Context, cdc codec.JSONCodec) json.RawMessage { + return cdc.MustMarshalJSON(am.keeper.ExportGenesis(ctx)) +} + +// ConsensusVersion implements AppModule/ConsensusVersion. +func (AppModule) ConsensusVersion() uint64 { return consensusVersion } + +// ---------------------------------------------------------------------------- +// App Wiring Setup +// ---------------------------------------------------------------------------- + +func init() { + appmodule.Register( + &modulev1.Module{}, + appmodule.Provide(ProvideModule), + ) +} + +type ModuleInputs struct { + depinject.In + + Cdc codec.Codec + Config *modulev1.Module + StoreService store.KVStoreService + Logger log.Logger + + AccountKeeper authKeeper.AccountKeeper + BankKeeper bankKeeper.Keeper + StakingKeeper *stakingKeeper.Keeper + DistributionKeeper *distributionKeeper.Keeper +} + +type ModuleOutputs struct { + depinject.Out + + LiquidKeeper *keeper.Keeper + Module appmodule.AppModule +} + +func ProvideModule(in ModuleInputs) ModuleOutputs { + // default to governance authority if not provided + authority := authtypes.NewModuleAddress(types.ModuleName) + if in.Config.Authority != "" { + authority = authtypes.NewModuleAddressOrBech32Address(in.Config.Authority) + } + k := keeper.NewKeeper( + in.Cdc, + in.StoreService, + + in.AccountKeeper, + in.BankKeeper, + in.StakingKeeper, + in.DistributionKeeper, + authority.String(), + ) + m := NewAppModule( + in.Cdc, + k, + in.AccountKeeper, + in.BankKeeper, + stakingKeeper.Keeper{}, + ) + + return ModuleOutputs{LiquidKeeper: k, Module: m} +} diff --git a/x/liquid/types/codec.go b/x/liquid/types/codec.go new file mode 100644 index 00000000..6d4133e9 --- /dev/null +++ b/x/liquid/types/codec.go @@ -0,0 +1,44 @@ +package types + +import ( + "github.com/cosmos/cosmos-sdk/codec" + "github.com/cosmos/cosmos-sdk/codec/legacy" + "github.com/cosmos/cosmos-sdk/codec/types" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/types/msgservice" +) + +// RegisterLegacyAminoCodec registers the necessary x/liquid interfaces +// and concrete types on the provided LegacyAmino codec. These types are used +// for Amino JSON serialization. +func RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) { + legacy.RegisterAminoMsg(cdc, &MsgUpdateParams{}, "gaia/x/liquid/MsgUpdateParams") + legacy.RegisterAminoMsg(cdc, &MsgTokenizeShares{}, "gaia/MsgTokenizeShares") + legacy.RegisterAminoMsg(cdc, &MsgRedeemTokensForShares{}, "gaia/MsgRedeemTokensForShares") + legacy.RegisterAminoMsg(cdc, &MsgTransferTokenizeShareRecord{}, "gaia/MsgTransferTokenizeShareRecord") + legacy.RegisterAminoMsg(cdc, &MsgDisableTokenizeShares{}, "gaia/MsgDisableTokenizeShares") + legacy.RegisterAminoMsg(cdc, &MsgEnableTokenizeShares{}, "gaia/MsgEnableTokenizeShares") + // TODO eric I haven't included UnbondValidator + // legacy.RegisterAminoMsg(cdc, &MsgUnbondValidator{}, "cosmos-sdk/MsgUnbondValidator") + legacy.RegisterAminoMsg(cdc, &MsgWithdrawTokenizeShareRecordReward{}, "gaia/MsgWithdrawTokenizeReward") + legacy.RegisterAminoMsg(cdc, &MsgWithdrawAllTokenizeShareRecordReward{}, "gaia/MsgWithdrawAllTokenizeReward") + + cdc.RegisterConcrete(Params{}, "gaia/x/liquid/Params", nil) +} + +// RegisterInterfaces registers the x/liquid interfaces with the interface registry +func RegisterInterfaces(registry types.InterfaceRegistry) { + registry.RegisterImplementations( + (*sdk.Msg)(nil), + &MsgUpdateParams{}, + &MsgTokenizeShares{}, + &MsgRedeemTokensForShares{}, + &MsgTransferTokenizeShareRecord{}, + &MsgDisableTokenizeShares{}, + &MsgEnableTokenizeShares{}, + &MsgWithdrawTokenizeShareRecordReward{}, + &MsgWithdrawAllTokenizeShareRecordReward{}, + ) + + msgservice.RegisterMsgServiceDesc(registry, &_Msg_serviceDesc) +} diff --git a/x/liquid/types/errors.go b/x/liquid/types/errors.go new file mode 100644 index 00000000..8fceb292 --- /dev/null +++ b/x/liquid/types/errors.go @@ -0,0 +1,24 @@ +package types + +import "cosmossdk.io/errors" + +// x/liquid module sentinel errors +var ( + ErrRedelegationInProgress = errors.Register(ModuleName, 120, "delegator is not allowed to tokenize shares from validator with a redelegation in progress") + ErrInsufficientShares = errors.Register(ModuleName, 22, "insufficient delegation shares") + ErrTokenizeShareRecordNotExists = errors.Register(ModuleName, 102, "tokenize share record not exists") + ErrTokenizeShareRecordAlreadyExists = errors.Register(ModuleName, 103, "tokenize share record already exists") + ErrNotTokenizeShareRecordOwner = errors.Register(ModuleName, 104, "not tokenize share record owner") + ErrExceedingFreeVestingDelegations = errors.Register(ModuleName, 105, "trying to exceed vested free delegation for vesting account") + ErrOnlyBondDenomAllowdForTokenize = errors.Register(ModuleName, 106, "only bond denom is allowed for tokenize") + ErrGlobalLiquidStakingCapExceeded = errors.Register(ModuleName, 111, "delegation or tokenization exceeds the global cap") + ErrValidatorLiquidStakingCapExceeded = errors.Register(ModuleName, 112, "delegation or tokenization exceeds the validator cap") + ErrTokenizeSharesDisabledForAccount = errors.Register(ModuleName, 113, "tokenize shares currently disabled for account") + ErrTokenizeSharesAlreadyEnabledForAccount = errors.Register(ModuleName, 115, "tokenize shares is already enabled for this account") + ErrTokenizeSharesAlreadyDisabledForAccount = errors.Register(ModuleName, 116, "tokenize shares is already disabled for this account") + ErrValidatorLiquidSharesUnderflow = errors.Register(ModuleName, 117, "validator liquid shares underflow") + ErrTotalLiquidStakedUnderflow = errors.Register(ModuleName, 118, "total liquid staked underflow") + ErrNotEnoughBalance = errors.Register(ModuleName, 101, "not enough balance") + ErrTinyRedemptionAmount = errors.Register(ModuleName, 119, "too few tokens to redeem (truncates to zero tokens)") + ErrNoValidatorFound = errors.Register(ModuleName, 3, "validator does not exist") +) diff --git a/x/liquid/types/events.go b/x/liquid/types/events.go new file mode 100644 index 00000000..3c7e2375 --- /dev/null +++ b/x/liquid/types/events.go @@ -0,0 +1,17 @@ +package types + +// liquid module event types +const ( + EventTypeTokenizeShares = "tokenize_shares" + EventTypeRedeemShares = "redeem_shares" + EventTypeTransferTokenizeShareRecord = "transfer_tokenize_share_record" + EventTypeWithdrawTokenizeShareReward = "withdraw_tokenize_share_reward" + + AttributeKeyValidator = "validator" + AttributeKeyDelegator = "delegator" + AttributeKeyShareOwner = "share_owner" + AttributeKeyShareRecordID = "share_record_id" + AttributeKeyAmount = "amount" + AttributeKeyTokenizedShares = "tokenized_shares" + AttributeKeyWithdrawAddress = "withdraw_address" +) diff --git a/x/liquid/types/expected_keepers.go b/x/liquid/types/expected_keepers.go new file mode 100644 index 00000000..1166d6c4 --- /dev/null +++ b/x/liquid/types/expected_keepers.go @@ -0,0 +1,64 @@ +package types + +import ( + "context" + + "cosmossdk.io/core/address" + "cosmossdk.io/math" + + sdk "github.com/cosmos/cosmos-sdk/types" + stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" +) + +// AccountKeeper defines the expected account keeper (noalias) +type AccountKeeper interface { + AddressCodec() address.Codec + GetAccount(ctx context.Context, addr sdk.AccAddress) sdk.AccountI // only used for simulation + GetModuleAddress(name string) sdk.AccAddress + GetModuleAccount(ctx context.Context, moduleName string) sdk.ModuleAccountI +} + +// BankKeeper defines the expected interface needed to retrieve account balances. +type BankKeeper interface { + GetAllBalances(ctx context.Context, addr sdk.AccAddress) sdk.Coins + GetBalance(ctx context.Context, addr sdk.AccAddress, denom string) sdk.Coin + SendCoins(ctx context.Context, fromAddr, toAddr sdk.AccAddress, amt sdk.Coins) error + SendCoinsFromAccountToModule(ctx context.Context, senderAddr sdk.AccAddress, recipientModule string, amt sdk.Coins) error + SendCoinsFromModuleToAccount(ctx context.Context, senderModule string, recipientAddr sdk.AccAddress, amt sdk.Coins) error + SendCoinsFromModuleToModule(ctx context.Context, senderPool, recipientPool string, amt sdk.Coins) error + UndelegateCoinsFromModuleToAccount(ctx context.Context, senderModule string, recipientAddr sdk.AccAddress, amt sdk.Coins) error + MintCoins(cts context.Context, name string, amt sdk.Coins) error + BurnCoins(ctx context.Context, name string, amt sdk.Coins) error + BlockedAddr(addr sdk.AccAddress) bool + SpendableCoins(ctx context.Context, addr sdk.AccAddress) sdk.Coins +} + +// StakingKeeper defines the expected interface needed to interact with the x/staking keeper. +type StakingKeeper interface { + GetParams(ctx context.Context) (params stakingtypes.Params, err error) + TotalBondedTokens(ctx context.Context) (math.Int, error) + GetValidator(ctx context.Context, addr sdk.ValAddress) (validator stakingtypes.Validator, err error) + SetValidator(ctx context.Context, validator stakingtypes.Validator) error + GetAllValidators(ctx context.Context) (validators []stakingtypes.Validator, err error) + GetDelegation(ctx context.Context, delAddr sdk.AccAddress, valAddr sdk.ValAddress) (stakingtypes.Delegation, error) + GetAllDelegations(ctx context.Context) (delegations []stakingtypes.Delegation, err error) + ValidatorAddressCodec() address.Codec + BondDenom(ctx context.Context) (string, error) + ValidateUnbondAmount(ctx context.Context, delAddr sdk.AccAddress, valAddr sdk.ValAddress, amt math.Int) (shares math.LegacyDec, err error) + HasReceivingRedelegation(ctx context.Context, delAddr sdk.AccAddress, valDstAddr sdk.ValAddress) (bool, error) + Unbond(ctx context.Context, delAddr sdk.AccAddress, valAddr sdk.ValAddress, shares math.LegacyDec) (amount math.Int, err error) + Delegate( + ctx context.Context, delAddr sdk.AccAddress, bondAmt math.Int, tokenSrc stakingtypes.BondStatus, + validator stakingtypes.Validator, subtractAccount bool, + ) (newShares math.LegacyDec, err error) + Validator(ctx context.Context, address sdk.ValAddress) (stakingtypes.ValidatorI, error) + Delegation(ctx context.Context, addrDel sdk.AccAddress, addrVal sdk.ValAddress) (stakingtypes.DelegationI, error) + GetValidatorDelegations(ctx context.Context, valAddr sdk.ValAddress) (delegations []stakingtypes.Delegation, err error) +} + +// DistributionKeeper defines the expected interface needed to interact with the x/distribution keeper. +type DistributionKeeper interface { + WithdrawDelegationRewards(ctx context.Context, delAddr sdk.AccAddress, valAddr sdk.ValAddress) (sdk.Coins, error) + IncrementValidatorPeriod(ctx context.Context, val stakingtypes.ValidatorI) (uint64, error) + CalculateDelegationRewards(ctx context.Context, val stakingtypes.ValidatorI, del stakingtypes.DelegationI, endingPeriod uint64) (rewards sdk.DecCoins, err error) +} diff --git a/x/liquid/types/genesis.go b/x/liquid/types/genesis.go new file mode 100644 index 00000000..852dabbc --- /dev/null +++ b/x/liquid/types/genesis.go @@ -0,0 +1,29 @@ +package types + +import "cosmossdk.io/math" + +func NewGenesisState( + params Params, + tsr []TokenizeShareRecord, + recordID uint64, + liquidStakeTokens math.Int, + locks []TokenizeShareLock, +) *GenesisState { + return &GenesisState{ + Params: params, + TokenizeShareRecords: tsr, + LastTokenizeShareRecordId: recordID, + TotalLiquidStakedTokens: liquidStakeTokens, + TokenizeShareLocks: locks, + } +} + +func DefaultGenesisState() *GenesisState { + return &GenesisState{ + Params: DefaultParams(), + } +} + +func ValidateGenesis(gs *GenesisState) error { + return gs.Params.Validate() +} diff --git a/x/liquid/types/genesis.pb.go b/x/liquid/types/genesis.pb.go new file mode 100644 index 00000000..b3e20ac7 --- /dev/null +++ b/x/liquid/types/genesis.pb.go @@ -0,0 +1,833 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: kyve/liquid/v1beta1/genesis.proto + +package types + +import ( + cosmossdk_io_math "cosmossdk.io/math" + fmt "fmt" + _ "github.com/cosmos/cosmos-sdk/types/tx/amino" + _ "github.com/cosmos/gogoproto/gogoproto" + proto "github.com/cosmos/gogoproto/proto" + github_com_cosmos_gogoproto_types "github.com/cosmos/gogoproto/types" + _ "google.golang.org/protobuf/types/known/timestamppb" + io "io" + math "math" + math_bits "math/bits" + time "time" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf +var _ = time.Kitchen + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +// GenesisState defines the liquid module's genesis state. +type GenesisState struct { + // params defines all the parameters of related to deposit. + Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"` + // store tokenize share records to provide reward to record owners + TokenizeShareRecords []TokenizeShareRecord `protobuf:"bytes,9,rep,name=tokenize_share_records,json=tokenizeShareRecords,proto3" json:"tokenize_share_records"` + // last tokenize share record id, used for next share record id calculation + LastTokenizeShareRecordId uint64 `protobuf:"varint,10,opt,name=last_tokenize_share_record_id,json=lastTokenizeShareRecordId,proto3" json:"last_tokenize_share_record_id,omitempty"` + // total number of liquid staked tokens at genesis + TotalLiquidStakedTokens cosmossdk_io_math.Int `protobuf:"bytes,11,opt,name=total_liquid_staked_tokens,json=totalLiquidStakedTokens,proto3,customtype=cosmossdk.io/math.Int" json:"total_liquid_staked_tokens" yaml:"total_liquid_staked_tokens"` + // tokenize shares locks at genesis + TokenizeShareLocks []TokenizeShareLock `protobuf:"bytes,12,rep,name=tokenize_share_locks,json=tokenizeShareLocks,proto3" json:"tokenize_share_locks"` +} + +func (m *GenesisState) Reset() { *m = GenesisState{} } +func (m *GenesisState) String() string { return proto.CompactTextString(m) } +func (*GenesisState) ProtoMessage() {} +func (*GenesisState) Descriptor() ([]byte, []int) { + return fileDescriptor_1e0ff895af275f9d, []int{0} +} +func (m *GenesisState) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GenesisState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GenesisState.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 *GenesisState) XXX_Merge(src proto.Message) { + xxx_messageInfo_GenesisState.Merge(m, src) +} +func (m *GenesisState) XXX_Size() int { + return m.Size() +} +func (m *GenesisState) XXX_DiscardUnknown() { + xxx_messageInfo_GenesisState.DiscardUnknown(m) +} + +var xxx_messageInfo_GenesisState proto.InternalMessageInfo + +func (m *GenesisState) GetParams() Params { + if m != nil { + return m.Params + } + return Params{} +} + +func (m *GenesisState) GetTokenizeShareRecords() []TokenizeShareRecord { + if m != nil { + return m.TokenizeShareRecords + } + return nil +} + +func (m *GenesisState) GetLastTokenizeShareRecordId() uint64 { + if m != nil { + return m.LastTokenizeShareRecordId + } + return 0 +} + +func (m *GenesisState) GetTokenizeShareLocks() []TokenizeShareLock { + if m != nil { + return m.TokenizeShareLocks + } + return nil +} + +// TokenizeSharesLock required for specifying account locks at genesis +type TokenizeShareLock struct { + // Address of the account that is locked + Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` + // Status of the lock (LOCKED or LOCK_EXPIRING) + Status string `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"` + // Completion time if the lock is expiring + CompletionTime time.Time `protobuf:"bytes,3,opt,name=completion_time,json=completionTime,proto3,stdtime" json:"completion_time" yaml:"completion_time"` +} + +func (m *TokenizeShareLock) Reset() { *m = TokenizeShareLock{} } +func (m *TokenizeShareLock) String() string { return proto.CompactTextString(m) } +func (*TokenizeShareLock) ProtoMessage() {} +func (*TokenizeShareLock) Descriptor() ([]byte, []int) { + return fileDescriptor_1e0ff895af275f9d, []int{1} +} +func (m *TokenizeShareLock) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TokenizeShareLock) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_TokenizeShareLock.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 *TokenizeShareLock) XXX_Merge(src proto.Message) { + xxx_messageInfo_TokenizeShareLock.Merge(m, src) +} +func (m *TokenizeShareLock) XXX_Size() int { + return m.Size() +} +func (m *TokenizeShareLock) XXX_DiscardUnknown() { + xxx_messageInfo_TokenizeShareLock.DiscardUnknown(m) +} + +var xxx_messageInfo_TokenizeShareLock proto.InternalMessageInfo + +func (m *TokenizeShareLock) GetAddress() string { + if m != nil { + return m.Address + } + return "" +} + +func (m *TokenizeShareLock) GetStatus() string { + if m != nil { + return m.Status + } + return "" +} + +func (m *TokenizeShareLock) GetCompletionTime() time.Time { + if m != nil { + return m.CompletionTime + } + return time.Time{} +} + +func init() { + proto.RegisterType((*GenesisState)(nil), "kyve.liquid.v1beta1.GenesisState") + proto.RegisterType((*TokenizeShareLock)(nil), "kyve.liquid.v1beta1.TokenizeShareLock") +} + +func init() { proto.RegisterFile("kyve/liquid/v1beta1/genesis.proto", fileDescriptor_1e0ff895af275f9d) } + +var fileDescriptor_1e0ff895af275f9d = []byte{ + // 518 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x53, 0x4d, 0x8b, 0xd3, 0x40, + 0x18, 0x6e, 0xdc, 0xa5, 0xd2, 0x69, 0x51, 0x36, 0xd6, 0x1a, 0x2b, 0x26, 0xdd, 0x1c, 0xa4, 0x28, + 0xcc, 0xb0, 0xeb, 0xcd, 0x83, 0x48, 0x60, 0x91, 0xc5, 0x45, 0x24, 0x5d, 0x04, 0x3d, 0x18, 0xa6, + 0xc9, 0x98, 0x0e, 0xf9, 0x98, 0x9a, 0x79, 0xbb, 0x5a, 0x2f, 0xfe, 0x85, 0xfd, 0x19, 0x9e, 0xc4, + 0x9f, 0xb1, 0xc7, 0xbd, 0x29, 0x1e, 0xaa, 0xb4, 0x07, 0xef, 0xfb, 0x0b, 0x24, 0x33, 0x29, 0x42, + 0x37, 0xe2, 0x25, 0xe4, 0x9d, 0xe7, 0x23, 0x0f, 0x6f, 0x9e, 0x41, 0xbb, 0xc9, 0xfc, 0x84, 0x91, + 0x94, 0xbf, 0x9b, 0xf1, 0x88, 0x9c, 0xec, 0x8d, 0x19, 0xd0, 0x3d, 0x12, 0xb3, 0x9c, 0x49, 0x2e, + 0xf1, 0xb4, 0x10, 0x20, 0xcc, 0x1b, 0x25, 0x05, 0x6b, 0x0a, 0xae, 0x28, 0xfd, 0x6e, 0x2c, 0x62, + 0xa1, 0x70, 0x52, 0xbe, 0x69, 0x6a, 0x7f, 0x50, 0xe7, 0x56, 0x29, 0x35, 0x63, 0x87, 0x66, 0x3c, + 0x17, 0x44, 0x3d, 0xab, 0x23, 0x27, 0x16, 0x22, 0x4e, 0x19, 0x51, 0xd3, 0x78, 0xf6, 0x96, 0x00, + 0xcf, 0x98, 0x04, 0x9a, 0x4d, 0x35, 0xc1, 0xfd, 0xb6, 0x85, 0x3a, 0x4f, 0x75, 0xa4, 0x11, 0x50, + 0x60, 0xe6, 0x63, 0xd4, 0x9c, 0xd2, 0x82, 0x66, 0xd2, 0x32, 0x06, 0xc6, 0xb0, 0xbd, 0x7f, 0x07, + 0xd7, 0x44, 0xc4, 0x2f, 0x14, 0xc5, 0x6b, 0x9d, 0x2d, 0x9c, 0xc6, 0xe7, 0xdf, 0x5f, 0xef, 0x1b, + 0x7e, 0xa5, 0x32, 0x23, 0xd4, 0x03, 0x91, 0xb0, 0x9c, 0x7f, 0x64, 0x81, 0x9c, 0xd0, 0x82, 0x05, + 0x05, 0x0b, 0x45, 0x11, 0x49, 0xab, 0x35, 0xd8, 0x1a, 0xb6, 0xf7, 0x87, 0xb5, 0x7e, 0xc7, 0x95, + 0x64, 0x54, 0x2a, 0x7c, 0x25, 0xf0, 0xb6, 0x4b, 0x73, 0xbf, 0x0b, 0x97, 0x21, 0x69, 0x3e, 0x41, + 0x77, 0x53, 0x2a, 0x21, 0xa8, 0xfd, 0x54, 0xc0, 0x23, 0x0b, 0x0d, 0x8c, 0xe1, 0xb6, 0x7f, 0xbb, + 0x24, 0xd5, 0x78, 0x1f, 0x46, 0xe6, 0x27, 0xd4, 0x07, 0x01, 0x34, 0x0d, 0x74, 0x92, 0x40, 0x02, + 0x4d, 0x58, 0xa4, 0x0d, 0xa5, 0xd5, 0x1e, 0x18, 0xc3, 0x8e, 0xe7, 0x95, 0x09, 0x7e, 0x2c, 0x9c, + 0x9b, 0xa1, 0x90, 0x99, 0x90, 0x32, 0x4a, 0x30, 0x17, 0x24, 0xa3, 0x30, 0xc1, 0x87, 0x39, 0x5c, + 0x2c, 0x9c, 0xdd, 0x39, 0xcd, 0xd2, 0x47, 0xee, 0xbf, 0x8d, 0x5c, 0xff, 0x96, 0x02, 0x8f, 0x14, + 0x36, 0x52, 0x90, 0xca, 0x23, 0xcd, 0x37, 0xa8, 0xbb, 0x91, 0x3e, 0x15, 0x61, 0x22, 0xad, 0x8e, + 0x5a, 0xd3, 0xbd, 0xff, 0xaf, 0xe9, 0x48, 0x84, 0x49, 0xb5, 0x24, 0x13, 0x36, 0x01, 0xe9, 0x7e, + 0x31, 0xd0, 0xce, 0x25, 0xbe, 0x69, 0xa1, 0xab, 0x34, 0x8a, 0x0a, 0x26, 0xf5, 0xff, 0x6d, 0xf9, + 0xeb, 0xd1, 0xec, 0xa1, 0xa6, 0x04, 0x0a, 0x33, 0x69, 0x5d, 0x51, 0x40, 0x35, 0x99, 0x31, 0xba, + 0x1e, 0x8a, 0x6c, 0x9a, 0x32, 0xe0, 0x22, 0x0f, 0xca, 0xfe, 0x58, 0x5b, 0xaa, 0x19, 0x7d, 0xac, + 0xcb, 0x85, 0xd7, 0xe5, 0xc2, 0xc7, 0xeb, 0x72, 0x79, 0x6e, 0x19, 0xeb, 0x62, 0xe1, 0xf4, 0xf4, + 0x82, 0x36, 0x0c, 0xdc, 0xd3, 0x9f, 0x8e, 0xe1, 0x5f, 0xfb, 0x7b, 0x5a, 0x0a, 0xbd, 0x83, 0xb3, + 0xa5, 0x6d, 0x9c, 0x2f, 0x6d, 0xe3, 0xd7, 0xd2, 0x36, 0x4e, 0x57, 0x76, 0xe3, 0x7c, 0x65, 0x37, + 0xbe, 0xaf, 0xec, 0xc6, 0xeb, 0x07, 0x31, 0x87, 0xc9, 0x6c, 0x8c, 0x43, 0x91, 0x91, 0x67, 0xaf, + 0x5e, 0x1e, 0x3c, 0x67, 0xf0, 0x5e, 0x14, 0x09, 0x09, 0x27, 0x94, 0xe7, 0xe4, 0xc3, 0xfa, 0x52, + 0xc0, 0x7c, 0xca, 0xe4, 0xb8, 0xa9, 0xe2, 0x3c, 0xfc, 0x13, 0x00, 0x00, 0xff, 0xff, 0xba, 0x94, + 0x18, 0xc6, 0x7e, 0x03, 0x00, 0x00, +} + +func (m *GenesisState) 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 *GenesisState) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.TokenizeShareLocks) > 0 { + for iNdEx := len(m.TokenizeShareLocks) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.TokenizeShareLocks[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x62 + } + } + { + size := m.TotalLiquidStakedTokens.Size() + i -= size + if _, err := m.TotalLiquidStakedTokens.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x5a + if m.LastTokenizeShareRecordId != 0 { + i = encodeVarintGenesis(dAtA, i, uint64(m.LastTokenizeShareRecordId)) + i-- + dAtA[i] = 0x50 + } + if len(m.TokenizeShareRecords) > 0 { + for iNdEx := len(m.TokenizeShareRecords) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.TokenizeShareRecords[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x4a + } + } + { + size, err := m.Params.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *TokenizeShareLock) 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 *TokenizeShareLock) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *TokenizeShareLock) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + n2, err2 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.CompletionTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.CompletionTime):]) + if err2 != nil { + return 0, err2 + } + i -= n2 + i = encodeVarintGenesis(dAtA, i, uint64(n2)) + i-- + dAtA[i] = 0x1a + if len(m.Status) > 0 { + i -= len(m.Status) + copy(dAtA[i:], m.Status) + i = encodeVarintGenesis(dAtA, i, uint64(len(m.Status))) + i-- + dAtA[i] = 0x12 + } + if len(m.Address) > 0 { + i -= len(m.Address) + copy(dAtA[i:], m.Address) + i = encodeVarintGenesis(dAtA, i, uint64(len(m.Address))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintGenesis(dAtA []byte, offset int, v uint64) int { + offset -= sovGenesis(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *GenesisState) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Params.Size() + n += 1 + l + sovGenesis(uint64(l)) + if len(m.TokenizeShareRecords) > 0 { + for _, e := range m.TokenizeShareRecords { + l = e.Size() + n += 1 + l + sovGenesis(uint64(l)) + } + } + if m.LastTokenizeShareRecordId != 0 { + n += 1 + sovGenesis(uint64(m.LastTokenizeShareRecordId)) + } + l = m.TotalLiquidStakedTokens.Size() + n += 1 + l + sovGenesis(uint64(l)) + if len(m.TokenizeShareLocks) > 0 { + for _, e := range m.TokenizeShareLocks { + l = e.Size() + n += 1 + l + sovGenesis(uint64(l)) + } + } + return n +} + +func (m *TokenizeShareLock) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Address) + if l > 0 { + n += 1 + l + sovGenesis(uint64(l)) + } + l = len(m.Status) + if l > 0 { + n += 1 + l + sovGenesis(uint64(l)) + } + l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.CompletionTime) + n += 1 + l + sovGenesis(uint64(l)) + return n +} + +func sovGenesis(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozGenesis(x uint64) (n int) { + return sovGenesis(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *GenesisState) 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 ErrIntOverflowGenesis + } + 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: GenesisState: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GenesisState: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TokenizeShareRecords", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.TokenizeShareRecords = append(m.TokenizeShareRecords, TokenizeShareRecord{}) + if err := m.TokenizeShareRecords[len(m.TokenizeShareRecords)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LastTokenizeShareRecordId", wireType) + } + m.LastTokenizeShareRecordId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.LastTokenizeShareRecordId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TotalLiquidStakedTokens", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.TotalLiquidStakedTokens.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TokenizeShareLocks", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.TokenizeShareLocks = append(m.TokenizeShareLocks, TokenizeShareLock{}) + if err := m.TokenizeShareLocks[len(m.TokenizeShareLocks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenesis(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenesis + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TokenizeShareLock) 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 ErrIntOverflowGenesis + } + 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: TokenizeShareLock: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: TokenizeShareLock: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + 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 ErrInvalidLengthGenesis + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Address = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + 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 ErrInvalidLengthGenesis + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Status = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CompletionTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.CompletionTime, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenesis(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenesis + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipGenesis(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGenesis + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGenesis + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGenesis + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthGenesis + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupGenesis + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthGenesis + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthGenesis = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowGenesis = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupGenesis = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/liquid/types/keys.go b/x/liquid/types/keys.go new file mode 100644 index 00000000..b635f3fe --- /dev/null +++ b/x/liquid/types/keys.go @@ -0,0 +1,73 @@ +package types + +import ( + "time" + + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/types/address" +) + +const ( + // ModuleName is the name of the liquid module + ModuleName = "liquid" + + // StoreKey is the string store representation + StoreKey = ModuleName + + // RouterKey is the msg router key for the liquid module + RouterKey = ModuleName + + // Prefix for module accounts that custodian tokenized shares + TokenizeShareModuleAccountPrefix = "tokenizeshare_" +) + +var ( + // Keys for store prefixes + // Last* values are constant during a block. + ParamsKey = []byte{0x51} // prefix for parameters for module x/liquid + + TokenizeShareRecordPrefix = []byte{0x1} // key for tokenizeshare record prefix + TokenizeShareRecordIDByOwnerPrefix = []byte{0x2} // key for tokenizeshare record id by owner prefix + TokenizeShareRecordIDByDenomPrefix = []byte{0x3} // key for tokenizeshare record id by denom prefix + LastTokenizeShareRecordIDKey = []byte{0x4} // key for last tokenize share record id + TotalLiquidStakedTokensKey = []byte{0x5} // key for total liquid staked tokens + TokenizeSharesLockPrefix = []byte{0x6} // key for locking tokenize shares + TokenizeSharesUnlockQueuePrefix = []byte{0x7} // key for the queue that unlocks tokenize shares + LiquidValidatorPrefix = []byte{0x8} // key for liquid validator prefix +) + +// GetLiquidValidatorKey returns the key of the liquid validator. +func GetLiquidValidatorKey(operatorAddress sdk.ValAddress) []byte { + return append(LiquidValidatorPrefix, address.MustLengthPrefix(operatorAddress)...) +} + +// GetTokenizeShareRecordByIndexKey returns the key of the specified id. Intended for querying the tokenizeShareRecord by the id. +func GetTokenizeShareRecordByIndexKey(id uint64) []byte { + return append(TokenizeShareRecordPrefix, sdk.Uint64ToBigEndian(id)...) +} + +// GetTokenizeShareRecordIDsByOwnerPrefix returns the key of the specified owner. Intended for querying all tokenizeShareRecords of an owner +func GetTokenizeShareRecordIDsByOwnerPrefix(owner sdk.AccAddress) []byte { + return append(TokenizeShareRecordIDByOwnerPrefix, address.MustLengthPrefix(owner)...) +} + +// GetTokenizeShareRecordIdByOwnerAndIdKey returns the key of the specified owner and id. Intended for setting tokenizeShareRecord of an owner +func GetTokenizeShareRecordIDByOwnerAndIDKey(owner sdk.AccAddress, id uint64) []byte { + return append(append(TokenizeShareRecordIDByOwnerPrefix, address.MustLengthPrefix(owner)...), sdk.Uint64ToBigEndian(id)...) +} + +func GetTokenizeShareRecordIDByDenomKey(denom string) []byte { + return append(TokenizeShareRecordIDByDenomPrefix, []byte(denom)...) +} + +// GetTokenizeSharesLockKey returns the key for storing a tokenize share lock for a specified account +func GetTokenizeSharesLockKey(owner sdk.AccAddress) []byte { + return append(TokenizeSharesLockPrefix, address.MustLengthPrefix(owner)...) +} + +// GetTokenizeShareAuthorizationTimeKey returns the prefix key used for getting a set of pending +// tokenize share unlocks that complete at the given time +func GetTokenizeShareAuthorizationTimeKey(timestamp time.Time) []byte { + bz := sdk.FormatTimeBytes(timestamp) + return append(TokenizeSharesUnlockQueuePrefix, bz...) +} diff --git a/x/liquid/types/liquid.pb.go b/x/liquid/types/liquid.pb.go new file mode 100644 index 00000000..2bfdec09 --- /dev/null +++ b/x/liquid/types/liquid.pb.go @@ -0,0 +1,1407 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: kyve/liquid/v1beta1/liquid.proto + +package types + +import ( + cosmossdk_io_math "cosmossdk.io/math" + fmt "fmt" + _ "github.com/cosmos/cosmos-proto" + github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" + types "github.com/cosmos/cosmos-sdk/types" + _ "github.com/cosmos/cosmos-sdk/types/tx/amino" + _ "github.com/cosmos/gogoproto/gogoproto" + proto "github.com/cosmos/gogoproto/proto" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +// TokenizeShareLockStatus indicates whether the address is able to tokenize +// shares +type TokenizeShareLockStatus int32 + +const ( + // UNSPECIFIED defines an empty tokenize share lock status + TOKENIZE_SHARE_LOCK_STATUS_UNSPECIFIED TokenizeShareLockStatus = 0 + // LOCKED indicates the account is locked and cannot tokenize shares + TOKENIZE_SHARE_LOCK_STATUS_LOCKED TokenizeShareLockStatus = 1 + // UNLOCKED indicates the account is unlocked and can tokenize shares + TOKENIZE_SHARE_LOCK_STATUS_UNLOCKED TokenizeShareLockStatus = 2 + // LOCK_EXPIRING indicates the account is unable to tokenize shares, but + // will be able to tokenize shortly (after 1 unbonding period) + TOKENIZE_SHARE_LOCK_STATUS_LOCK_EXPIRING TokenizeShareLockStatus = 3 +) + +var TokenizeShareLockStatus_name = map[int32]string{ + 0: "TOKENIZE_SHARE_LOCK_STATUS_UNSPECIFIED", + 1: "TOKENIZE_SHARE_LOCK_STATUS_LOCKED", + 2: "TOKENIZE_SHARE_LOCK_STATUS_UNLOCKED", + 3: "TOKENIZE_SHARE_LOCK_STATUS_LOCK_EXPIRING", +} + +var TokenizeShareLockStatus_value = map[string]int32{ + "TOKENIZE_SHARE_LOCK_STATUS_UNSPECIFIED": 0, + "TOKENIZE_SHARE_LOCK_STATUS_LOCKED": 1, + "TOKENIZE_SHARE_LOCK_STATUS_UNLOCKED": 2, + "TOKENIZE_SHARE_LOCK_STATUS_LOCK_EXPIRING": 3, +} + +func (x TokenizeShareLockStatus) String() string { + return proto.EnumName(TokenizeShareLockStatus_name, int32(x)) +} + +func (TokenizeShareLockStatus) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_83fe2aa3458e6a34, []int{0} +} + +// Params defines the parameters for the x/liquid module. +type Params struct { + // global_liquid_staking_cap represents a cap on the portion of stake that + // comes from liquid staking providers + GlobalLiquidStakingCap cosmossdk_io_math.LegacyDec `protobuf:"bytes,8,opt,name=global_liquid_staking_cap,json=globalLiquidStakingCap,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"global_liquid_staking_cap" yaml:"global_liquid_staking_cap"` + // validator_liquid_staking_cap represents a cap on the portion of stake that + // comes from liquid staking providers for a specific validator + ValidatorLiquidStakingCap cosmossdk_io_math.LegacyDec `protobuf:"bytes,9,opt,name=validator_liquid_staking_cap,json=validatorLiquidStakingCap,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"validator_liquid_staking_cap" yaml:"validator_liquid_staking_cap"` +} + +func (m *Params) Reset() { *m = Params{} } +func (m *Params) String() string { return proto.CompactTextString(m) } +func (*Params) ProtoMessage() {} +func (*Params) Descriptor() ([]byte, []int) { + return fileDescriptor_83fe2aa3458e6a34, []int{0} +} +func (m *Params) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Params) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Params.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 *Params) XXX_Merge(src proto.Message) { + xxx_messageInfo_Params.Merge(m, src) +} +func (m *Params) XXX_Size() int { + return m.Size() +} +func (m *Params) XXX_DiscardUnknown() { + xxx_messageInfo_Params.DiscardUnknown(m) +} + +var xxx_messageInfo_Params proto.InternalMessageInfo + +// TokenizeShareRecord represents a tokenized delegation +type TokenizeShareRecord struct { + Id uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + Owner string `protobuf:"bytes,2,opt,name=owner,proto3" json:"owner,omitempty"` + ModuleAccount string `protobuf:"bytes,3,opt,name=module_account,json=moduleAccount,proto3" json:"module_account,omitempty"` + Validator string `protobuf:"bytes,4,opt,name=validator,proto3" json:"validator,omitempty"` +} + +func (m *TokenizeShareRecord) Reset() { *m = TokenizeShareRecord{} } +func (m *TokenizeShareRecord) String() string { return proto.CompactTextString(m) } +func (*TokenizeShareRecord) ProtoMessage() {} +func (*TokenizeShareRecord) Descriptor() ([]byte, []int) { + return fileDescriptor_83fe2aa3458e6a34, []int{1} +} +func (m *TokenizeShareRecord) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TokenizeShareRecord) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_TokenizeShareRecord.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 *TokenizeShareRecord) XXX_Merge(src proto.Message) { + xxx_messageInfo_TokenizeShareRecord.Merge(m, src) +} +func (m *TokenizeShareRecord) XXX_Size() int { + return m.Size() +} +func (m *TokenizeShareRecord) XXX_DiscardUnknown() { + xxx_messageInfo_TokenizeShareRecord.DiscardUnknown(m) +} + +var xxx_messageInfo_TokenizeShareRecord proto.InternalMessageInfo + +func (m *TokenizeShareRecord) GetId() uint64 { + if m != nil { + return m.Id + } + return 0 +} + +func (m *TokenizeShareRecord) GetOwner() string { + if m != nil { + return m.Owner + } + return "" +} + +func (m *TokenizeShareRecord) GetModuleAccount() string { + if m != nil { + return m.ModuleAccount + } + return "" +} + +func (m *TokenizeShareRecord) GetValidator() string { + if m != nil { + return m.Validator + } + return "" +} + +// PendingTokenizeShareAuthorizations stores a list of addresses that have their +// tokenize share enablement in progress +type PendingTokenizeShareAuthorizations struct { + Addresses []string `protobuf:"bytes,1,rep,name=addresses,proto3" json:"addresses,omitempty"` +} + +func (m *PendingTokenizeShareAuthorizations) Reset() { *m = PendingTokenizeShareAuthorizations{} } +func (m *PendingTokenizeShareAuthorizations) String() string { return proto.CompactTextString(m) } +func (*PendingTokenizeShareAuthorizations) ProtoMessage() {} +func (*PendingTokenizeShareAuthorizations) Descriptor() ([]byte, []int) { + return fileDescriptor_83fe2aa3458e6a34, []int{2} +} +func (m *PendingTokenizeShareAuthorizations) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PendingTokenizeShareAuthorizations) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_PendingTokenizeShareAuthorizations.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 *PendingTokenizeShareAuthorizations) XXX_Merge(src proto.Message) { + xxx_messageInfo_PendingTokenizeShareAuthorizations.Merge(m, src) +} +func (m *PendingTokenizeShareAuthorizations) XXX_Size() int { + return m.Size() +} +func (m *PendingTokenizeShareAuthorizations) XXX_DiscardUnknown() { + xxx_messageInfo_PendingTokenizeShareAuthorizations.DiscardUnknown(m) +} + +var xxx_messageInfo_PendingTokenizeShareAuthorizations proto.InternalMessageInfo + +func (m *PendingTokenizeShareAuthorizations) GetAddresses() []string { + if m != nil { + return m.Addresses + } + return nil +} + +// TokenizeShareRecordReward represents the properties of tokenize share +type TokenizeShareRecordReward struct { + RecordId uint64 `protobuf:"varint,1,opt,name=record_id,json=recordId,proto3" json:"record_id,omitempty"` + Reward github_com_cosmos_cosmos_sdk_types.DecCoins `protobuf:"bytes,2,rep,name=reward,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.DecCoins" json:"reward"` +} + +func (m *TokenizeShareRecordReward) Reset() { *m = TokenizeShareRecordReward{} } +func (m *TokenizeShareRecordReward) String() string { return proto.CompactTextString(m) } +func (*TokenizeShareRecordReward) ProtoMessage() {} +func (*TokenizeShareRecordReward) Descriptor() ([]byte, []int) { + return fileDescriptor_83fe2aa3458e6a34, []int{3} +} +func (m *TokenizeShareRecordReward) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TokenizeShareRecordReward) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_TokenizeShareRecordReward.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 *TokenizeShareRecordReward) XXX_Merge(src proto.Message) { + xxx_messageInfo_TokenizeShareRecordReward.Merge(m, src) +} +func (m *TokenizeShareRecordReward) XXX_Size() int { + return m.Size() +} +func (m *TokenizeShareRecordReward) XXX_DiscardUnknown() { + xxx_messageInfo_TokenizeShareRecordReward.DiscardUnknown(m) +} + +var xxx_messageInfo_TokenizeShareRecordReward proto.InternalMessageInfo + +// LiquidValidator is the storage layout for details about a validator's liquid +// stake. +type LiquidValidator struct { + // operator_address defines the address of the validator's operator; bech + // encoded in JSON. + OperatorAddress string `protobuf:"bytes,1,opt,name=operator_address,json=operatorAddress,proto3" json:"operator_address,omitempty"` + // Number of shares either tokenized or owned by a liquid staking provider + LiquidShares cosmossdk_io_math.LegacyDec `protobuf:"bytes,3,opt,name=liquid_shares,json=liquidShares,proto3,customtype=cosmossdk.io/math.LegacyDec" json:"liquid_shares" yaml:"liquid_shares"` +} + +func (m *LiquidValidator) Reset() { *m = LiquidValidator{} } +func (m *LiquidValidator) String() string { return proto.CompactTextString(m) } +func (*LiquidValidator) ProtoMessage() {} +func (*LiquidValidator) Descriptor() ([]byte, []int) { + return fileDescriptor_83fe2aa3458e6a34, []int{4} +} +func (m *LiquidValidator) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *LiquidValidator) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_LiquidValidator.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 *LiquidValidator) XXX_Merge(src proto.Message) { + xxx_messageInfo_LiquidValidator.Merge(m, src) +} +func (m *LiquidValidator) XXX_Size() int { + return m.Size() +} +func (m *LiquidValidator) XXX_DiscardUnknown() { + xxx_messageInfo_LiquidValidator.DiscardUnknown(m) +} + +var xxx_messageInfo_LiquidValidator proto.InternalMessageInfo + +func init() { + proto.RegisterEnum("kyve.liquid.v1beta1.TokenizeShareLockStatus", TokenizeShareLockStatus_name, TokenizeShareLockStatus_value) + proto.RegisterType((*Params)(nil), "kyve.liquid.v1beta1.Params") + proto.RegisterType((*TokenizeShareRecord)(nil), "kyve.liquid.v1beta1.TokenizeShareRecord") + proto.RegisterType((*PendingTokenizeShareAuthorizations)(nil), "kyve.liquid.v1beta1.PendingTokenizeShareAuthorizations") + proto.RegisterType((*TokenizeShareRecordReward)(nil), "kyve.liquid.v1beta1.TokenizeShareRecordReward") + proto.RegisterType((*LiquidValidator)(nil), "kyve.liquid.v1beta1.LiquidValidator") +} + +func init() { proto.RegisterFile("kyve/liquid/v1beta1/liquid.proto", fileDescriptor_83fe2aa3458e6a34) } + +var fileDescriptor_83fe2aa3458e6a34 = []byte{ + // 762 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x54, 0x4d, 0x4f, 0xe3, 0x46, + 0x18, 0xce, 0x24, 0x29, 0x22, 0xd3, 0x02, 0xa9, 0x89, 0x5a, 0x07, 0xa8, 0x93, 0x1a, 0xd1, 0x46, + 0x69, 0x89, 0x45, 0xb9, 0xa5, 0xa7, 0x7c, 0xb8, 0x6d, 0x44, 0x14, 0x22, 0x3b, 0xa0, 0x16, 0xa9, + 0x72, 0x27, 0xf6, 0xc8, 0x19, 0x25, 0xf1, 0xa4, 0x1e, 0x07, 0x1a, 0x7e, 0x40, 0x85, 0x7a, 0xea, + 0xa5, 0x52, 0x4f, 0x15, 0x52, 0x2f, 0xab, 0x95, 0x56, 0xe2, 0xc0, 0x2f, 0xd8, 0x13, 0x7b, 0x43, + 0x9c, 0x56, 0x7b, 0x60, 0x11, 0x1c, 0xd8, 0xf3, 0xfe, 0x82, 0x95, 0x3d, 0x4e, 0x58, 0x56, 0x2c, + 0xcb, 0x25, 0x99, 0xf7, 0x79, 0x9f, 0x79, 0xfc, 0xbc, 0x1f, 0x36, 0xcc, 0x76, 0x47, 0xbb, 0x58, + 0xe9, 0x91, 0xdf, 0x87, 0xc4, 0x52, 0x76, 0xd7, 0xda, 0xd8, 0x43, 0x6b, 0x61, 0x58, 0x18, 0xb8, + 0xd4, 0xa3, 0xc2, 0xbc, 0xcf, 0x28, 0x84, 0x50, 0xc8, 0x58, 0x48, 0xd9, 0xd4, 0xa6, 0x41, 0x5e, + 0xf1, 0x4f, 0x9c, 0xba, 0xf0, 0x29, 0xea, 0x13, 0x87, 0x2a, 0xc1, 0x6f, 0x08, 0x49, 0x26, 0x65, + 0x7d, 0xca, 0x94, 0x36, 0x62, 0x78, 0xa2, 0x6f, 0x52, 0xe2, 0x84, 0xf9, 0x34, 0xcf, 0x1b, 0x5c, + 0x8b, 0x07, 0x3c, 0x25, 0x5f, 0x44, 0xe1, 0x54, 0x13, 0xb9, 0xa8, 0xcf, 0x84, 0x7f, 0x00, 0x4c, + 0xdb, 0x3d, 0xda, 0x46, 0x3d, 0x83, 0x1b, 0x31, 0x98, 0x87, 0xba, 0xc4, 0xb1, 0x0d, 0x13, 0x0d, + 0xc4, 0xe9, 0x2c, 0xc8, 0x25, 0xca, 0x3b, 0x27, 0xe7, 0x99, 0xc8, 0x8b, 0xf3, 0xcc, 0x22, 0x17, + 0x61, 0x56, 0xb7, 0x40, 0xa8, 0xd2, 0x47, 0x5e, 0xa7, 0x50, 0xc7, 0x36, 0x32, 0x47, 0x55, 0x6c, + 0xbe, 0x3e, 0xcf, 0x64, 0x47, 0xa8, 0xdf, 0x2b, 0xca, 0xef, 0x55, 0x93, 0xcf, 0x8e, 0x57, 0x61, + 0xe8, 0xa3, 0x8a, 0xcd, 0x47, 0xd7, 0x47, 0x79, 0xa0, 0x7d, 0xc6, 0xe9, 0xf5, 0x80, 0xad, 0x73, + 0x72, 0x05, 0x0d, 0x84, 0xff, 0x00, 0x5c, 0xda, 0x45, 0x3d, 0x62, 0x21, 0x8f, 0xba, 0x77, 0x59, + 0x4b, 0x04, 0xd6, 0x7e, 0x7d, 0x98, 0xb5, 0x65, 0x6e, 0xed, 0x3e, 0xc1, 0x3b, 0xdd, 0xa5, 0x27, + 0x37, 0xde, 0x35, 0x58, 0xfc, 0xe2, 0xd5, 0x61, 0x06, 0xfc, 0x75, 0x7d, 0x94, 0x4f, 0xd9, 0x88, + 0x20, 0xe5, 0x8f, 0xf1, 0xa4, 0x79, 0x5f, 0xe5, 0x3f, 0x01, 0x9c, 0x6f, 0xd1, 0x2e, 0x76, 0xc8, + 0x3e, 0xd6, 0x3b, 0xc8, 0xc5, 0x1a, 0x36, 0xa9, 0x6b, 0x09, 0xb3, 0x30, 0x4a, 0x2c, 0x11, 0x64, + 0x41, 0x2e, 0xae, 0x45, 0x89, 0x25, 0xa4, 0xe0, 0x47, 0x74, 0xcf, 0xc1, 0xae, 0x18, 0xf5, 0xeb, + 0xd1, 0x78, 0x20, 0xac, 0xc0, 0xd9, 0x3e, 0xb5, 0x86, 0x3d, 0x6c, 0x20, 0xd3, 0xa4, 0x43, 0xc7, + 0x13, 0x63, 0x41, 0x7a, 0x86, 0xa3, 0x25, 0x0e, 0x0a, 0x4b, 0x30, 0x31, 0x31, 0x28, 0xc6, 0x03, + 0xc6, 0x0d, 0x50, 0x8c, 0xfb, 0x0e, 0xe5, 0x32, 0x94, 0x9b, 0xd8, 0xb1, 0x88, 0x63, 0xdf, 0xb2, + 0x53, 0x1a, 0x7a, 0x1d, 0xea, 0x92, 0x7d, 0xe4, 0x11, 0xea, 0x30, 0x5f, 0x09, 0x59, 0x96, 0x8b, + 0x19, 0xc3, 0x4c, 0x04, 0xd9, 0x98, 0xaf, 0x34, 0x01, 0xe4, 0x27, 0x00, 0xa6, 0xef, 0x28, 0x46, + 0xc3, 0x7b, 0xc8, 0xb5, 0x84, 0x45, 0x98, 0x70, 0x83, 0xd8, 0x98, 0x54, 0x36, 0xcd, 0x81, 0x9a, + 0x25, 0x10, 0x38, 0xe5, 0x06, 0x34, 0x31, 0x9a, 0x8d, 0xe5, 0x3e, 0xfe, 0x6e, 0xa9, 0x10, 0xf6, + 0xd8, 0x5f, 0xdb, 0xf1, 0xd2, 0xfb, 0x0d, 0xaf, 0x50, 0xe2, 0x94, 0xd7, 0xfd, 0x71, 0x3e, 0x7e, + 0x99, 0xf9, 0xc6, 0x26, 0x5e, 0x67, 0xd8, 0x2e, 0x98, 0xb4, 0x1f, 0x6e, 0x6e, 0xf8, 0xb7, 0xca, + 0xac, 0xae, 0xe2, 0x8d, 0x06, 0x98, 0x8d, 0xef, 0x30, 0x2d, 0x7c, 0x40, 0x71, 0xfa, 0xe0, 0x30, + 0x13, 0xf9, 0xd7, 0xaf, 0xf9, 0x29, 0x80, 0x73, 0x7c, 0x60, 0xdb, 0xe3, 0x6e, 0x08, 0x15, 0x98, + 0xa4, 0x03, 0xec, 0x06, 0xd3, 0x0f, 0x2b, 0x0b, 0xcc, 0x26, 0xca, 0xe2, 0xd9, 0xf1, 0x6a, 0x2a, + 0x74, 0x55, 0xe2, 0x19, 0xdd, 0x73, 0x89, 0x63, 0x6b, 0x73, 0xe3, 0x1b, 0x21, 0x2c, 0xfc, 0x06, + 0x67, 0xc6, 0x9b, 0xe3, 0xb7, 0x81, 0xf1, 0xb1, 0x94, 0xbf, 0x7f, 0xd8, 0x16, 0xa6, 0xf8, 0x16, + 0xde, 0x52, 0x90, 0xb5, 0x4f, 0x78, 0x1c, 0xf4, 0x95, 0xdd, 0x14, 0x91, 0x7f, 0x06, 0xe0, 0xe7, + 0xb7, 0x9a, 0x5e, 0xa7, 0x66, 0x57, 0xf7, 0x90, 0x37, 0x64, 0x42, 0x1e, 0x7e, 0xd5, 0xda, 0xdc, + 0x50, 0x1b, 0xb5, 0x1d, 0xd5, 0xd0, 0x7f, 0x2a, 0x69, 0xaa, 0x51, 0xdf, 0xac, 0x6c, 0x18, 0x7a, + 0xab, 0xd4, 0xda, 0xd2, 0x8d, 0xad, 0x86, 0xde, 0x54, 0x2b, 0xb5, 0x1f, 0x6a, 0x6a, 0x35, 0x19, + 0x11, 0x56, 0xe0, 0x97, 0xf7, 0x70, 0xfd, 0xb3, 0x5a, 0x4d, 0x02, 0xe1, 0x6b, 0xb8, 0x7c, 0xaf, + 0x64, 0x48, 0x8c, 0x0a, 0xdf, 0xc2, 0xdc, 0x07, 0xf4, 0x0c, 0xf5, 0xe7, 0x66, 0x4d, 0xab, 0x35, + 0x7e, 0x4c, 0xc6, 0x16, 0xe2, 0x07, 0xff, 0x4b, 0x91, 0xb2, 0x7a, 0x72, 0x29, 0x81, 0xd3, 0x4b, + 0x09, 0x5c, 0x5c, 0x4a, 0xe0, 0xef, 0x2b, 0x29, 0x72, 0x7a, 0x25, 0x45, 0x9e, 0x5f, 0x49, 0x91, + 0x9d, 0xb7, 0x27, 0xbd, 0xf1, 0xcb, 0xb6, 0xda, 0xc0, 0xde, 0x1e, 0x75, 0xbb, 0x8a, 0xd9, 0x41, + 0xc4, 0xb9, 0x79, 0xab, 0x82, 0x91, 0xb7, 0xa7, 0x82, 0xcf, 0xd7, 0xfa, 0x9b, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x02, 0x76, 0xe9, 0xa8, 0x5b, 0x05, 0x00, 0x00, +} + +func (this *Params) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*Params) + if !ok { + that2, ok := that.(Params) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if !this.GlobalLiquidStakingCap.Equal(that1.GlobalLiquidStakingCap) { + return false + } + if !this.ValidatorLiquidStakingCap.Equal(that1.ValidatorLiquidStakingCap) { + return false + } + return true +} +func (this *TokenizeShareRecord) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*TokenizeShareRecord) + if !ok { + that2, ok := that.(TokenizeShareRecord) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if this.Id != that1.Id { + return false + } + if this.Owner != that1.Owner { + return false + } + if this.ModuleAccount != that1.ModuleAccount { + return false + } + if this.Validator != that1.Validator { + return false + } + return true +} +func (m *Params) 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 *Params) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size := m.ValidatorLiquidStakingCap.Size() + i -= size + if _, err := m.ValidatorLiquidStakingCap.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintLiquid(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x4a + { + size := m.GlobalLiquidStakingCap.Size() + i -= size + if _, err := m.GlobalLiquidStakingCap.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintLiquid(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x42 + return len(dAtA) - i, nil +} + +func (m *TokenizeShareRecord) 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 *TokenizeShareRecord) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *TokenizeShareRecord) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Validator) > 0 { + i -= len(m.Validator) + copy(dAtA[i:], m.Validator) + i = encodeVarintLiquid(dAtA, i, uint64(len(m.Validator))) + i-- + dAtA[i] = 0x22 + } + if len(m.ModuleAccount) > 0 { + i -= len(m.ModuleAccount) + copy(dAtA[i:], m.ModuleAccount) + i = encodeVarintLiquid(dAtA, i, uint64(len(m.ModuleAccount))) + i-- + dAtA[i] = 0x1a + } + if len(m.Owner) > 0 { + i -= len(m.Owner) + copy(dAtA[i:], m.Owner) + i = encodeVarintLiquid(dAtA, i, uint64(len(m.Owner))) + i-- + dAtA[i] = 0x12 + } + if m.Id != 0 { + i = encodeVarintLiquid(dAtA, i, uint64(m.Id)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *PendingTokenizeShareAuthorizations) 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 *PendingTokenizeShareAuthorizations) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *PendingTokenizeShareAuthorizations) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Addresses) > 0 { + for iNdEx := len(m.Addresses) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Addresses[iNdEx]) + copy(dAtA[i:], m.Addresses[iNdEx]) + i = encodeVarintLiquid(dAtA, i, uint64(len(m.Addresses[iNdEx]))) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *TokenizeShareRecordReward) 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 *TokenizeShareRecordReward) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *TokenizeShareRecordReward) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Reward) > 0 { + for iNdEx := len(m.Reward) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Reward[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintLiquid(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + if m.RecordId != 0 { + i = encodeVarintLiquid(dAtA, i, uint64(m.RecordId)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *LiquidValidator) 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 *LiquidValidator) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *LiquidValidator) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size := m.LiquidShares.Size() + i -= size + if _, err := m.LiquidShares.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintLiquid(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + if len(m.OperatorAddress) > 0 { + i -= len(m.OperatorAddress) + copy(dAtA[i:], m.OperatorAddress) + i = encodeVarintLiquid(dAtA, i, uint64(len(m.OperatorAddress))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintLiquid(dAtA []byte, offset int, v uint64) int { + offset -= sovLiquid(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *Params) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.GlobalLiquidStakingCap.Size() + n += 1 + l + sovLiquid(uint64(l)) + l = m.ValidatorLiquidStakingCap.Size() + n += 1 + l + sovLiquid(uint64(l)) + return n +} + +func (m *TokenizeShareRecord) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Id != 0 { + n += 1 + sovLiquid(uint64(m.Id)) + } + l = len(m.Owner) + if l > 0 { + n += 1 + l + sovLiquid(uint64(l)) + } + l = len(m.ModuleAccount) + if l > 0 { + n += 1 + l + sovLiquid(uint64(l)) + } + l = len(m.Validator) + if l > 0 { + n += 1 + l + sovLiquid(uint64(l)) + } + return n +} + +func (m *PendingTokenizeShareAuthorizations) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Addresses) > 0 { + for _, s := range m.Addresses { + l = len(s) + n += 1 + l + sovLiquid(uint64(l)) + } + } + return n +} + +func (m *TokenizeShareRecordReward) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.RecordId != 0 { + n += 1 + sovLiquid(uint64(m.RecordId)) + } + if len(m.Reward) > 0 { + for _, e := range m.Reward { + l = e.Size() + n += 1 + l + sovLiquid(uint64(l)) + } + } + return n +} + +func (m *LiquidValidator) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.OperatorAddress) + if l > 0 { + n += 1 + l + sovLiquid(uint64(l)) + } + l = m.LiquidShares.Size() + n += 1 + l + sovLiquid(uint64(l)) + return n +} + +func sovLiquid(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozLiquid(x uint64) (n int) { + return sovLiquid(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *Params) 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 ErrIntOverflowLiquid + } + 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: Params: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Params: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GlobalLiquidStakingCap", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquid + } + 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 ErrInvalidLengthLiquid + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthLiquid + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.GlobalLiquidStakingCap.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorLiquidStakingCap", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquid + } + 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 ErrInvalidLengthLiquid + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthLiquid + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.ValidatorLiquidStakingCap.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipLiquid(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthLiquid + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TokenizeShareRecord) 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 ErrIntOverflowLiquid + } + 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: TokenizeShareRecord: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: TokenizeShareRecord: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + m.Id = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquid + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Id |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Owner", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquid + } + 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 ErrInvalidLengthLiquid + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthLiquid + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Owner = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ModuleAccount", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquid + } + 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 ErrInvalidLengthLiquid + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthLiquid + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ModuleAccount = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Validator", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquid + } + 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 ErrInvalidLengthLiquid + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthLiquid + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Validator = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipLiquid(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthLiquid + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PendingTokenizeShareAuthorizations) 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 ErrIntOverflowLiquid + } + 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: PendingTokenizeShareAuthorizations: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PendingTokenizeShareAuthorizations: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Addresses", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquid + } + 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 ErrInvalidLengthLiquid + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthLiquid + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Addresses = append(m.Addresses, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipLiquid(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthLiquid + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TokenizeShareRecordReward) 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 ErrIntOverflowLiquid + } + 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: TokenizeShareRecordReward: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: TokenizeShareRecordReward: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RecordId", wireType) + } + m.RecordId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquid + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RecordId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Reward", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquid + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthLiquid + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthLiquid + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Reward = append(m.Reward, types.DecCoin{}) + if err := m.Reward[len(m.Reward)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipLiquid(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthLiquid + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *LiquidValidator) 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 ErrIntOverflowLiquid + } + 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: LiquidValidator: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: LiquidValidator: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OperatorAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquid + } + 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 ErrInvalidLengthLiquid + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthLiquid + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.OperatorAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LiquidShares", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquid + } + 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 ErrInvalidLengthLiquid + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthLiquid + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.LiquidShares.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipLiquid(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthLiquid + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipLiquid(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowLiquid + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowLiquid + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowLiquid + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthLiquid + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupLiquid + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthLiquid + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthLiquid = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowLiquid = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupLiquid = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/liquid/types/liquid_validator.go b/x/liquid/types/liquid_validator.go new file mode 100644 index 00000000..e8251b1e --- /dev/null +++ b/x/liquid/types/liquid_validator.go @@ -0,0 +1,25 @@ +package types + +import ( + "cosmossdk.io/math" + + "github.com/cosmos/cosmos-sdk/codec" +) + +// NewLiquidValidator constructs a new LiquidValidator +func NewLiquidValidator(operator string) LiquidValidator { + return LiquidValidator{ + OperatorAddress: operator, + LiquidShares: math.LegacyZeroDec(), + } +} + +func MustMarshalValidator(cdc codec.BinaryCodec, validator *LiquidValidator) []byte { + return cdc.MustMarshal(validator) +} + +// unmarshal from a store value +func UnmarshalValidator(cdc codec.BinaryCodec, value []byte) (v LiquidValidator, err error) { + err = cdc.Unmarshal(value, &v) + return v, err +} diff --git a/x/liquid/types/mocks/AccountKeeper.go b/x/liquid/types/mocks/AccountKeeper.go new file mode 100644 index 00000000..5156af00 --- /dev/null +++ b/x/liquid/types/mocks/AccountKeeper.go @@ -0,0 +1,234 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + address "cosmossdk.io/core/address" + + cosmos_sdktypes "github.com/cosmos/cosmos-sdk/types" + + mock "github.com/stretchr/testify/mock" +) + +// AccountKeeper is an autogenerated mock type for the AccountKeeper type +type AccountKeeper struct { + mock.Mock +} + +type AccountKeeper_Expecter struct { + mock *mock.Mock +} + +func (_m *AccountKeeper) EXPECT() *AccountKeeper_Expecter { + return &AccountKeeper_Expecter{mock: &_m.Mock} +} + +// AddressCodec provides a mock function with given fields: +func (_m *AccountKeeper) AddressCodec() address.Codec { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for AddressCodec") + } + + var r0 address.Codec + if rf, ok := ret.Get(0).(func() address.Codec); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(address.Codec) + } + } + + return r0 +} + +// AccountKeeper_AddressCodec_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddressCodec' +type AccountKeeper_AddressCodec_Call struct { + *mock.Call +} + +// AddressCodec is a helper method to define mock.On call +func (_e *AccountKeeper_Expecter) AddressCodec() *AccountKeeper_AddressCodec_Call { + return &AccountKeeper_AddressCodec_Call{Call: _e.mock.On("AddressCodec")} +} + +func (_c *AccountKeeper_AddressCodec_Call) Run(run func()) *AccountKeeper_AddressCodec_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *AccountKeeper_AddressCodec_Call) Return(_a0 address.Codec) *AccountKeeper_AddressCodec_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AccountKeeper_AddressCodec_Call) RunAndReturn(run func() address.Codec) *AccountKeeper_AddressCodec_Call { + _c.Call.Return(run) + return _c +} + +// GetAccount provides a mock function with given fields: ctx, addr +func (_m *AccountKeeper) GetAccount(ctx context.Context, addr cosmos_sdktypes.AccAddress) cosmos_sdktypes.AccountI { + ret := _m.Called(ctx, addr) + + if len(ret) == 0 { + panic("no return value specified for GetAccount") + } + + var r0 cosmos_sdktypes.AccountI + if rf, ok := ret.Get(0).(func(context.Context, cosmos_sdktypes.AccAddress) cosmos_sdktypes.AccountI); ok { + r0 = rf(ctx, addr) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(cosmos_sdktypes.AccountI) + } + } + + return r0 +} + +// AccountKeeper_GetAccount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAccount' +type AccountKeeper_GetAccount_Call struct { + *mock.Call +} + +// GetAccount is a helper method to define mock.On call +// - ctx context.Context +// - addr cosmos_sdktypes.AccAddress +func (_e *AccountKeeper_Expecter) GetAccount(ctx interface{}, addr interface{}) *AccountKeeper_GetAccount_Call { + return &AccountKeeper_GetAccount_Call{Call: _e.mock.On("GetAccount", ctx, addr)} +} + +func (_c *AccountKeeper_GetAccount_Call) Run(run func(ctx context.Context, addr cosmos_sdktypes.AccAddress)) *AccountKeeper_GetAccount_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(cosmos_sdktypes.AccAddress)) + }) + return _c +} + +func (_c *AccountKeeper_GetAccount_Call) Return(_a0 cosmos_sdktypes.AccountI) *AccountKeeper_GetAccount_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AccountKeeper_GetAccount_Call) RunAndReturn(run func(context.Context, cosmos_sdktypes.AccAddress) cosmos_sdktypes.AccountI) *AccountKeeper_GetAccount_Call { + _c.Call.Return(run) + return _c +} + +// GetModuleAccount provides a mock function with given fields: ctx, moduleName +func (_m *AccountKeeper) GetModuleAccount(ctx context.Context, moduleName string) cosmos_sdktypes.ModuleAccountI { + ret := _m.Called(ctx, moduleName) + + if len(ret) == 0 { + panic("no return value specified for GetModuleAccount") + } + + var r0 cosmos_sdktypes.ModuleAccountI + if rf, ok := ret.Get(0).(func(context.Context, string) cosmos_sdktypes.ModuleAccountI); ok { + r0 = rf(ctx, moduleName) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(cosmos_sdktypes.ModuleAccountI) + } + } + + return r0 +} + +// AccountKeeper_GetModuleAccount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetModuleAccount' +type AccountKeeper_GetModuleAccount_Call struct { + *mock.Call +} + +// GetModuleAccount is a helper method to define mock.On call +// - ctx context.Context +// - moduleName string +func (_e *AccountKeeper_Expecter) GetModuleAccount(ctx interface{}, moduleName interface{}) *AccountKeeper_GetModuleAccount_Call { + return &AccountKeeper_GetModuleAccount_Call{Call: _e.mock.On("GetModuleAccount", ctx, moduleName)} +} + +func (_c *AccountKeeper_GetModuleAccount_Call) Run(run func(ctx context.Context, moduleName string)) *AccountKeeper_GetModuleAccount_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *AccountKeeper_GetModuleAccount_Call) Return(_a0 cosmos_sdktypes.ModuleAccountI) *AccountKeeper_GetModuleAccount_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AccountKeeper_GetModuleAccount_Call) RunAndReturn(run func(context.Context, string) cosmos_sdktypes.ModuleAccountI) *AccountKeeper_GetModuleAccount_Call { + _c.Call.Return(run) + return _c +} + +// GetModuleAddress provides a mock function with given fields: name +func (_m *AccountKeeper) GetModuleAddress(name string) cosmos_sdktypes.AccAddress { + ret := _m.Called(name) + + if len(ret) == 0 { + panic("no return value specified for GetModuleAddress") + } + + var r0 cosmos_sdktypes.AccAddress + if rf, ok := ret.Get(0).(func(string) cosmos_sdktypes.AccAddress); ok { + r0 = rf(name) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(cosmos_sdktypes.AccAddress) + } + } + + return r0 +} + +// AccountKeeper_GetModuleAddress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetModuleAddress' +type AccountKeeper_GetModuleAddress_Call struct { + *mock.Call +} + +// GetModuleAddress is a helper method to define mock.On call +// - name string +func (_e *AccountKeeper_Expecter) GetModuleAddress(name interface{}) *AccountKeeper_GetModuleAddress_Call { + return &AccountKeeper_GetModuleAddress_Call{Call: _e.mock.On("GetModuleAddress", name)} +} + +func (_c *AccountKeeper_GetModuleAddress_Call) Run(run func(name string)) *AccountKeeper_GetModuleAddress_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *AccountKeeper_GetModuleAddress_Call) Return(_a0 cosmos_sdktypes.AccAddress) *AccountKeeper_GetModuleAddress_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *AccountKeeper_GetModuleAddress_Call) RunAndReturn(run func(string) cosmos_sdktypes.AccAddress) *AccountKeeper_GetModuleAddress_Call { + _c.Call.Return(run) + return _c +} + +// NewAccountKeeper creates a new instance of AccountKeeper. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewAccountKeeper(t interface { + mock.TestingT + Cleanup(func()) +}, +) *AccountKeeper { + mock := &AccountKeeper{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/x/liquid/types/mocks/BankKeeper.go b/x/liquid/types/mocks/BankKeeper.go new file mode 100644 index 00000000..6c8150f1 --- /dev/null +++ b/x/liquid/types/mocks/BankKeeper.go @@ -0,0 +1,572 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" + + types "github.com/cosmos/cosmos-sdk/types" +) + +// BankKeeper is an autogenerated mock type for the BankKeeper type +type BankKeeper struct { + mock.Mock +} + +type BankKeeper_Expecter struct { + mock *mock.Mock +} + +func (_m *BankKeeper) EXPECT() *BankKeeper_Expecter { + return &BankKeeper_Expecter{mock: &_m.Mock} +} + +// BlockedAddr provides a mock function with given fields: addr +func (_m *BankKeeper) BlockedAddr(addr types.AccAddress) bool { + ret := _m.Called(addr) + + if len(ret) == 0 { + panic("no return value specified for BlockedAddr") + } + + var r0 bool + if rf, ok := ret.Get(0).(func(types.AccAddress) bool); ok { + r0 = rf(addr) + } else { + r0 = ret.Get(0).(bool) + } + + return r0 +} + +// BankKeeper_BlockedAddr_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BlockedAddr' +type BankKeeper_BlockedAddr_Call struct { + *mock.Call +} + +// BlockedAddr is a helper method to define mock.On call +// - addr types.AccAddress +func (_e *BankKeeper_Expecter) BlockedAddr(addr interface{}) *BankKeeper_BlockedAddr_Call { + return &BankKeeper_BlockedAddr_Call{Call: _e.mock.On("BlockedAddr", addr)} +} + +func (_c *BankKeeper_BlockedAddr_Call) Run(run func(addr types.AccAddress)) *BankKeeper_BlockedAddr_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(types.AccAddress)) + }) + return _c +} + +func (_c *BankKeeper_BlockedAddr_Call) Return(_a0 bool) *BankKeeper_BlockedAddr_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *BankKeeper_BlockedAddr_Call) RunAndReturn(run func(types.AccAddress) bool) *BankKeeper_BlockedAddr_Call { + _c.Call.Return(run) + return _c +} + +// BurnCoins provides a mock function with given fields: ctx, name, amt +func (_m *BankKeeper) BurnCoins(ctx context.Context, name string, amt types.Coins) error { + ret := _m.Called(ctx, name, amt) + + if len(ret) == 0 { + panic("no return value specified for BurnCoins") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, string, types.Coins) error); ok { + r0 = rf(ctx, name, amt) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// BankKeeper_BurnCoins_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BurnCoins' +type BankKeeper_BurnCoins_Call struct { + *mock.Call +} + +// BurnCoins is a helper method to define mock.On call +// - ctx context.Context +// - name string +// - amt types.Coins +func (_e *BankKeeper_Expecter) BurnCoins(ctx interface{}, name interface{}, amt interface{}) *BankKeeper_BurnCoins_Call { + return &BankKeeper_BurnCoins_Call{Call: _e.mock.On("BurnCoins", ctx, name, amt)} +} + +func (_c *BankKeeper_BurnCoins_Call) Run(run func(ctx context.Context, name string, amt types.Coins)) *BankKeeper_BurnCoins_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(types.Coins)) + }) + return _c +} + +func (_c *BankKeeper_BurnCoins_Call) Return(_a0 error) *BankKeeper_BurnCoins_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *BankKeeper_BurnCoins_Call) RunAndReturn(run func(context.Context, string, types.Coins) error) *BankKeeper_BurnCoins_Call { + _c.Call.Return(run) + return _c +} + +// GetAllBalances provides a mock function with given fields: ctx, addr +func (_m *BankKeeper) GetAllBalances(ctx context.Context, addr types.AccAddress) types.Coins { + ret := _m.Called(ctx, addr) + + if len(ret) == 0 { + panic("no return value specified for GetAllBalances") + } + + var r0 types.Coins + if rf, ok := ret.Get(0).(func(context.Context, types.AccAddress) types.Coins); ok { + r0 = rf(ctx, addr) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(types.Coins) + } + } + + return r0 +} + +// BankKeeper_GetAllBalances_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllBalances' +type BankKeeper_GetAllBalances_Call struct { + *mock.Call +} + +// GetAllBalances is a helper method to define mock.On call +// - ctx context.Context +// - addr types.AccAddress +func (_e *BankKeeper_Expecter) GetAllBalances(ctx interface{}, addr interface{}) *BankKeeper_GetAllBalances_Call { + return &BankKeeper_GetAllBalances_Call{Call: _e.mock.On("GetAllBalances", ctx, addr)} +} + +func (_c *BankKeeper_GetAllBalances_Call) Run(run func(ctx context.Context, addr types.AccAddress)) *BankKeeper_GetAllBalances_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(types.AccAddress)) + }) + return _c +} + +func (_c *BankKeeper_GetAllBalances_Call) Return(_a0 types.Coins) *BankKeeper_GetAllBalances_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *BankKeeper_GetAllBalances_Call) RunAndReturn(run func(context.Context, types.AccAddress) types.Coins) *BankKeeper_GetAllBalances_Call { + _c.Call.Return(run) + return _c +} + +// GetBalance provides a mock function with given fields: ctx, addr, denom +func (_m *BankKeeper) GetBalance(ctx context.Context, addr types.AccAddress, denom string) types.Coin { + ret := _m.Called(ctx, addr, denom) + + if len(ret) == 0 { + panic("no return value specified for GetBalance") + } + + var r0 types.Coin + if rf, ok := ret.Get(0).(func(context.Context, types.AccAddress, string) types.Coin); ok { + r0 = rf(ctx, addr, denom) + } else { + r0 = ret.Get(0).(types.Coin) + } + + return r0 +} + +// BankKeeper_GetBalance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBalance' +type BankKeeper_GetBalance_Call struct { + *mock.Call +} + +// GetBalance is a helper method to define mock.On call +// - ctx context.Context +// - addr types.AccAddress +// - denom string +func (_e *BankKeeper_Expecter) GetBalance(ctx interface{}, addr interface{}, denom interface{}) *BankKeeper_GetBalance_Call { + return &BankKeeper_GetBalance_Call{Call: _e.mock.On("GetBalance", ctx, addr, denom)} +} + +func (_c *BankKeeper_GetBalance_Call) Run(run func(ctx context.Context, addr types.AccAddress, denom string)) *BankKeeper_GetBalance_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(types.AccAddress), args[2].(string)) + }) + return _c +} + +func (_c *BankKeeper_GetBalance_Call) Return(_a0 types.Coin) *BankKeeper_GetBalance_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *BankKeeper_GetBalance_Call) RunAndReturn(run func(context.Context, types.AccAddress, string) types.Coin) *BankKeeper_GetBalance_Call { + _c.Call.Return(run) + return _c +} + +// MintCoins provides a mock function with given fields: cts, name, amt +func (_m *BankKeeper) MintCoins(cts context.Context, name string, amt types.Coins) error { + ret := _m.Called(cts, name, amt) + + if len(ret) == 0 { + panic("no return value specified for MintCoins") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, string, types.Coins) error); ok { + r0 = rf(cts, name, amt) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// BankKeeper_MintCoins_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MintCoins' +type BankKeeper_MintCoins_Call struct { + *mock.Call +} + +// MintCoins is a helper method to define mock.On call +// - cts context.Context +// - name string +// - amt types.Coins +func (_e *BankKeeper_Expecter) MintCoins(cts interface{}, name interface{}, amt interface{}) *BankKeeper_MintCoins_Call { + return &BankKeeper_MintCoins_Call{Call: _e.mock.On("MintCoins", cts, name, amt)} +} + +func (_c *BankKeeper_MintCoins_Call) Run(run func(cts context.Context, name string, amt types.Coins)) *BankKeeper_MintCoins_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(types.Coins)) + }) + return _c +} + +func (_c *BankKeeper_MintCoins_Call) Return(_a0 error) *BankKeeper_MintCoins_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *BankKeeper_MintCoins_Call) RunAndReturn(run func(context.Context, string, types.Coins) error) *BankKeeper_MintCoins_Call { + _c.Call.Return(run) + return _c +} + +// SendCoins provides a mock function with given fields: ctx, fromAddr, toAddr, amt +func (_m *BankKeeper) SendCoins(ctx context.Context, fromAddr types.AccAddress, toAddr types.AccAddress, amt types.Coins) error { + ret := _m.Called(ctx, fromAddr, toAddr, amt) + + if len(ret) == 0 { + panic("no return value specified for SendCoins") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, types.AccAddress, types.AccAddress, types.Coins) error); ok { + r0 = rf(ctx, fromAddr, toAddr, amt) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// BankKeeper_SendCoins_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendCoins' +type BankKeeper_SendCoins_Call struct { + *mock.Call +} + +// SendCoins is a helper method to define mock.On call +// - ctx context.Context +// - fromAddr types.AccAddress +// - toAddr types.AccAddress +// - amt types.Coins +func (_e *BankKeeper_Expecter) SendCoins(ctx interface{}, fromAddr interface{}, toAddr interface{}, amt interface{}) *BankKeeper_SendCoins_Call { + return &BankKeeper_SendCoins_Call{Call: _e.mock.On("SendCoins", ctx, fromAddr, toAddr, amt)} +} + +func (_c *BankKeeper_SendCoins_Call) Run(run func(ctx context.Context, fromAddr types.AccAddress, toAddr types.AccAddress, amt types.Coins)) *BankKeeper_SendCoins_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(types.AccAddress), args[2].(types.AccAddress), args[3].(types.Coins)) + }) + return _c +} + +func (_c *BankKeeper_SendCoins_Call) Return(_a0 error) *BankKeeper_SendCoins_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *BankKeeper_SendCoins_Call) RunAndReturn(run func(context.Context, types.AccAddress, types.AccAddress, types.Coins) error) *BankKeeper_SendCoins_Call { + _c.Call.Return(run) + return _c +} + +// SendCoinsFromAccountToModule provides a mock function with given fields: ctx, senderAddr, recipientModule, amt +func (_m *BankKeeper) SendCoinsFromAccountToModule(ctx context.Context, senderAddr types.AccAddress, recipientModule string, amt types.Coins) error { + ret := _m.Called(ctx, senderAddr, recipientModule, amt) + + if len(ret) == 0 { + panic("no return value specified for SendCoinsFromAccountToModule") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, types.AccAddress, string, types.Coins) error); ok { + r0 = rf(ctx, senderAddr, recipientModule, amt) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// BankKeeper_SendCoinsFromAccountToModule_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendCoinsFromAccountToModule' +type BankKeeper_SendCoinsFromAccountToModule_Call struct { + *mock.Call +} + +// SendCoinsFromAccountToModule is a helper method to define mock.On call +// - ctx context.Context +// - senderAddr types.AccAddress +// - recipientModule string +// - amt types.Coins +func (_e *BankKeeper_Expecter) SendCoinsFromAccountToModule(ctx interface{}, senderAddr interface{}, recipientModule interface{}, amt interface{}) *BankKeeper_SendCoinsFromAccountToModule_Call { + return &BankKeeper_SendCoinsFromAccountToModule_Call{Call: _e.mock.On("SendCoinsFromAccountToModule", ctx, senderAddr, recipientModule, amt)} +} + +func (_c *BankKeeper_SendCoinsFromAccountToModule_Call) Run(run func(ctx context.Context, senderAddr types.AccAddress, recipientModule string, amt types.Coins)) *BankKeeper_SendCoinsFromAccountToModule_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(types.AccAddress), args[2].(string), args[3].(types.Coins)) + }) + return _c +} + +func (_c *BankKeeper_SendCoinsFromAccountToModule_Call) Return(_a0 error) *BankKeeper_SendCoinsFromAccountToModule_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *BankKeeper_SendCoinsFromAccountToModule_Call) RunAndReturn(run func(context.Context, types.AccAddress, string, types.Coins) error) *BankKeeper_SendCoinsFromAccountToModule_Call { + _c.Call.Return(run) + return _c +} + +// SendCoinsFromModuleToAccount provides a mock function with given fields: ctx, senderModule, recipientAddr, amt +func (_m *BankKeeper) SendCoinsFromModuleToAccount(ctx context.Context, senderModule string, recipientAddr types.AccAddress, amt types.Coins) error { + ret := _m.Called(ctx, senderModule, recipientAddr, amt) + + if len(ret) == 0 { + panic("no return value specified for SendCoinsFromModuleToAccount") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, string, types.AccAddress, types.Coins) error); ok { + r0 = rf(ctx, senderModule, recipientAddr, amt) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// BankKeeper_SendCoinsFromModuleToAccount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendCoinsFromModuleToAccount' +type BankKeeper_SendCoinsFromModuleToAccount_Call struct { + *mock.Call +} + +// SendCoinsFromModuleToAccount is a helper method to define mock.On call +// - ctx context.Context +// - senderModule string +// - recipientAddr types.AccAddress +// - amt types.Coins +func (_e *BankKeeper_Expecter) SendCoinsFromModuleToAccount(ctx interface{}, senderModule interface{}, recipientAddr interface{}, amt interface{}) *BankKeeper_SendCoinsFromModuleToAccount_Call { + return &BankKeeper_SendCoinsFromModuleToAccount_Call{Call: _e.mock.On("SendCoinsFromModuleToAccount", ctx, senderModule, recipientAddr, amt)} +} + +func (_c *BankKeeper_SendCoinsFromModuleToAccount_Call) Run(run func(ctx context.Context, senderModule string, recipientAddr types.AccAddress, amt types.Coins)) *BankKeeper_SendCoinsFromModuleToAccount_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(types.AccAddress), args[3].(types.Coins)) + }) + return _c +} + +func (_c *BankKeeper_SendCoinsFromModuleToAccount_Call) Return(_a0 error) *BankKeeper_SendCoinsFromModuleToAccount_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *BankKeeper_SendCoinsFromModuleToAccount_Call) RunAndReturn(run func(context.Context, string, types.AccAddress, types.Coins) error) *BankKeeper_SendCoinsFromModuleToAccount_Call { + _c.Call.Return(run) + return _c +} + +// SendCoinsFromModuleToModule provides a mock function with given fields: ctx, senderPool, recipientPool, amt +func (_m *BankKeeper) SendCoinsFromModuleToModule(ctx context.Context, senderPool string, recipientPool string, amt types.Coins) error { + ret := _m.Called(ctx, senderPool, recipientPool, amt) + + if len(ret) == 0 { + panic("no return value specified for SendCoinsFromModuleToModule") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, string, string, types.Coins) error); ok { + r0 = rf(ctx, senderPool, recipientPool, amt) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// BankKeeper_SendCoinsFromModuleToModule_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendCoinsFromModuleToModule' +type BankKeeper_SendCoinsFromModuleToModule_Call struct { + *mock.Call +} + +// SendCoinsFromModuleToModule is a helper method to define mock.On call +// - ctx context.Context +// - senderPool string +// - recipientPool string +// - amt types.Coins +func (_e *BankKeeper_Expecter) SendCoinsFromModuleToModule(ctx interface{}, senderPool interface{}, recipientPool interface{}, amt interface{}) *BankKeeper_SendCoinsFromModuleToModule_Call { + return &BankKeeper_SendCoinsFromModuleToModule_Call{Call: _e.mock.On("SendCoinsFromModuleToModule", ctx, senderPool, recipientPool, amt)} +} + +func (_c *BankKeeper_SendCoinsFromModuleToModule_Call) Run(run func(ctx context.Context, senderPool string, recipientPool string, amt types.Coins)) *BankKeeper_SendCoinsFromModuleToModule_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(types.Coins)) + }) + return _c +} + +func (_c *BankKeeper_SendCoinsFromModuleToModule_Call) Return(_a0 error) *BankKeeper_SendCoinsFromModuleToModule_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *BankKeeper_SendCoinsFromModuleToModule_Call) RunAndReturn(run func(context.Context, string, string, types.Coins) error) *BankKeeper_SendCoinsFromModuleToModule_Call { + _c.Call.Return(run) + return _c +} + +// SpendableCoins provides a mock function with given fields: ctx, addr +func (_m *BankKeeper) SpendableCoins(ctx context.Context, addr types.AccAddress) types.Coins { + ret := _m.Called(ctx, addr) + + if len(ret) == 0 { + panic("no return value specified for SpendableCoins") + } + + var r0 types.Coins + if rf, ok := ret.Get(0).(func(context.Context, types.AccAddress) types.Coins); ok { + r0 = rf(ctx, addr) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(types.Coins) + } + } + + return r0 +} + +// BankKeeper_SpendableCoins_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SpendableCoins' +type BankKeeper_SpendableCoins_Call struct { + *mock.Call +} + +// SpendableCoins is a helper method to define mock.On call +// - ctx context.Context +// - addr types.AccAddress +func (_e *BankKeeper_Expecter) SpendableCoins(ctx interface{}, addr interface{}) *BankKeeper_SpendableCoins_Call { + return &BankKeeper_SpendableCoins_Call{Call: _e.mock.On("SpendableCoins", ctx, addr)} +} + +func (_c *BankKeeper_SpendableCoins_Call) Run(run func(ctx context.Context, addr types.AccAddress)) *BankKeeper_SpendableCoins_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(types.AccAddress)) + }) + return _c +} + +func (_c *BankKeeper_SpendableCoins_Call) Return(_a0 types.Coins) *BankKeeper_SpendableCoins_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *BankKeeper_SpendableCoins_Call) RunAndReturn(run func(context.Context, types.AccAddress) types.Coins) *BankKeeper_SpendableCoins_Call { + _c.Call.Return(run) + return _c +} + +// UndelegateCoinsFromModuleToAccount provides a mock function with given fields: ctx, senderModule, recipientAddr, amt +func (_m *BankKeeper) UndelegateCoinsFromModuleToAccount(ctx context.Context, senderModule string, recipientAddr types.AccAddress, amt types.Coins) error { + ret := _m.Called(ctx, senderModule, recipientAddr, amt) + + if len(ret) == 0 { + panic("no return value specified for UndelegateCoinsFromModuleToAccount") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, string, types.AccAddress, types.Coins) error); ok { + r0 = rf(ctx, senderModule, recipientAddr, amt) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// BankKeeper_UndelegateCoinsFromModuleToAccount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UndelegateCoinsFromModuleToAccount' +type BankKeeper_UndelegateCoinsFromModuleToAccount_Call struct { + *mock.Call +} + +// UndelegateCoinsFromModuleToAccount is a helper method to define mock.On call +// - ctx context.Context +// - senderModule string +// - recipientAddr types.AccAddress +// - amt types.Coins +func (_e *BankKeeper_Expecter) UndelegateCoinsFromModuleToAccount(ctx interface{}, senderModule interface{}, recipientAddr interface{}, amt interface{}) *BankKeeper_UndelegateCoinsFromModuleToAccount_Call { + return &BankKeeper_UndelegateCoinsFromModuleToAccount_Call{Call: _e.mock.On("UndelegateCoinsFromModuleToAccount", ctx, senderModule, recipientAddr, amt)} +} + +func (_c *BankKeeper_UndelegateCoinsFromModuleToAccount_Call) Run(run func(ctx context.Context, senderModule string, recipientAddr types.AccAddress, amt types.Coins)) *BankKeeper_UndelegateCoinsFromModuleToAccount_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(types.AccAddress), args[3].(types.Coins)) + }) + return _c +} + +func (_c *BankKeeper_UndelegateCoinsFromModuleToAccount_Call) Return(_a0 error) *BankKeeper_UndelegateCoinsFromModuleToAccount_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *BankKeeper_UndelegateCoinsFromModuleToAccount_Call) RunAndReturn(run func(context.Context, string, types.AccAddress, types.Coins) error) *BankKeeper_UndelegateCoinsFromModuleToAccount_Call { + _c.Call.Return(run) + return _c +} + +// NewBankKeeper creates a new instance of BankKeeper. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewBankKeeper(t interface { + mock.TestingT + Cleanup(func()) +}, +) *BankKeeper { + mock := &BankKeeper{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/x/liquid/types/mocks/DistributionKeeper.go b/x/liquid/types/mocks/DistributionKeeper.go new file mode 100644 index 00000000..041db53a --- /dev/null +++ b/x/liquid/types/mocks/DistributionKeeper.go @@ -0,0 +1,219 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + cosmos_sdktypes "github.com/cosmos/cosmos-sdk/types" + + mock "github.com/stretchr/testify/mock" + + types "github.com/cosmos/cosmos-sdk/x/staking/types" +) + +// DistributionKeeper is an autogenerated mock type for the DistributionKeeper type +type DistributionKeeper struct { + mock.Mock +} + +type DistributionKeeper_Expecter struct { + mock *mock.Mock +} + +func (_m *DistributionKeeper) EXPECT() *DistributionKeeper_Expecter { + return &DistributionKeeper_Expecter{mock: &_m.Mock} +} + +// CalculateDelegationRewards provides a mock function with given fields: ctx, val, del, endingPeriod +func (_m *DistributionKeeper) CalculateDelegationRewards(ctx context.Context, val types.ValidatorI, del types.DelegationI, endingPeriod uint64) (cosmos_sdktypes.DecCoins, error) { + ret := _m.Called(ctx, val, del, endingPeriod) + + if len(ret) == 0 { + panic("no return value specified for CalculateDelegationRewards") + } + + var r0 cosmos_sdktypes.DecCoins + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, types.ValidatorI, types.DelegationI, uint64) (cosmos_sdktypes.DecCoins, error)); ok { + return rf(ctx, val, del, endingPeriod) + } + if rf, ok := ret.Get(0).(func(context.Context, types.ValidatorI, types.DelegationI, uint64) cosmos_sdktypes.DecCoins); ok { + r0 = rf(ctx, val, del, endingPeriod) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(cosmos_sdktypes.DecCoins) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, types.ValidatorI, types.DelegationI, uint64) error); ok { + r1 = rf(ctx, val, del, endingPeriod) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// DistributionKeeper_CalculateDelegationRewards_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CalculateDelegationRewards' +type DistributionKeeper_CalculateDelegationRewards_Call struct { + *mock.Call +} + +// CalculateDelegationRewards is a helper method to define mock.On call +// - ctx context.Context +// - val types.ValidatorI +// - del types.DelegationI +// - endingPeriod uint64 +func (_e *DistributionKeeper_Expecter) CalculateDelegationRewards(ctx interface{}, val interface{}, del interface{}, endingPeriod interface{}) *DistributionKeeper_CalculateDelegationRewards_Call { + return &DistributionKeeper_CalculateDelegationRewards_Call{Call: _e.mock.On("CalculateDelegationRewards", ctx, val, del, endingPeriod)} +} + +func (_c *DistributionKeeper_CalculateDelegationRewards_Call) Run(run func(ctx context.Context, val types.ValidatorI, del types.DelegationI, endingPeriod uint64)) *DistributionKeeper_CalculateDelegationRewards_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(types.ValidatorI), args[2].(types.DelegationI), args[3].(uint64)) + }) + return _c +} + +func (_c *DistributionKeeper_CalculateDelegationRewards_Call) Return(rewards cosmos_sdktypes.DecCoins, err error) *DistributionKeeper_CalculateDelegationRewards_Call { + _c.Call.Return(rewards, err) + return _c +} + +func (_c *DistributionKeeper_CalculateDelegationRewards_Call) RunAndReturn(run func(context.Context, types.ValidatorI, types.DelegationI, uint64) (cosmos_sdktypes.DecCoins, error)) *DistributionKeeper_CalculateDelegationRewards_Call { + _c.Call.Return(run) + return _c +} + +// IncrementValidatorPeriod provides a mock function with given fields: ctx, val +func (_m *DistributionKeeper) IncrementValidatorPeriod(ctx context.Context, val types.ValidatorI) (uint64, error) { + ret := _m.Called(ctx, val) + + if len(ret) == 0 { + panic("no return value specified for IncrementValidatorPeriod") + } + + var r0 uint64 + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, types.ValidatorI) (uint64, error)); ok { + return rf(ctx, val) + } + if rf, ok := ret.Get(0).(func(context.Context, types.ValidatorI) uint64); ok { + r0 = rf(ctx, val) + } else { + r0 = ret.Get(0).(uint64) + } + + if rf, ok := ret.Get(1).(func(context.Context, types.ValidatorI) error); ok { + r1 = rf(ctx, val) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// DistributionKeeper_IncrementValidatorPeriod_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IncrementValidatorPeriod' +type DistributionKeeper_IncrementValidatorPeriod_Call struct { + *mock.Call +} + +// IncrementValidatorPeriod is a helper method to define mock.On call +// - ctx context.Context +// - val types.ValidatorI +func (_e *DistributionKeeper_Expecter) IncrementValidatorPeriod(ctx interface{}, val interface{}) *DistributionKeeper_IncrementValidatorPeriod_Call { + return &DistributionKeeper_IncrementValidatorPeriod_Call{Call: _e.mock.On("IncrementValidatorPeriod", ctx, val)} +} + +func (_c *DistributionKeeper_IncrementValidatorPeriod_Call) Run(run func(ctx context.Context, val types.ValidatorI)) *DistributionKeeper_IncrementValidatorPeriod_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(types.ValidatorI)) + }) + return _c +} + +func (_c *DistributionKeeper_IncrementValidatorPeriod_Call) Return(_a0 uint64, _a1 error) *DistributionKeeper_IncrementValidatorPeriod_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *DistributionKeeper_IncrementValidatorPeriod_Call) RunAndReturn(run func(context.Context, types.ValidatorI) (uint64, error)) *DistributionKeeper_IncrementValidatorPeriod_Call { + _c.Call.Return(run) + return _c +} + +// WithdrawDelegationRewards provides a mock function with given fields: ctx, delAddr, valAddr +func (_m *DistributionKeeper) WithdrawDelegationRewards(ctx context.Context, delAddr cosmos_sdktypes.AccAddress, valAddr cosmos_sdktypes.ValAddress) (cosmos_sdktypes.Coins, error) { + ret := _m.Called(ctx, delAddr, valAddr) + + if len(ret) == 0 { + panic("no return value specified for WithdrawDelegationRewards") + } + + var r0 cosmos_sdktypes.Coins + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, cosmos_sdktypes.AccAddress, cosmos_sdktypes.ValAddress) (cosmos_sdktypes.Coins, error)); ok { + return rf(ctx, delAddr, valAddr) + } + if rf, ok := ret.Get(0).(func(context.Context, cosmos_sdktypes.AccAddress, cosmos_sdktypes.ValAddress) cosmos_sdktypes.Coins); ok { + r0 = rf(ctx, delAddr, valAddr) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(cosmos_sdktypes.Coins) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, cosmos_sdktypes.AccAddress, cosmos_sdktypes.ValAddress) error); ok { + r1 = rf(ctx, delAddr, valAddr) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// DistributionKeeper_WithdrawDelegationRewards_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithdrawDelegationRewards' +type DistributionKeeper_WithdrawDelegationRewards_Call struct { + *mock.Call +} + +// WithdrawDelegationRewards is a helper method to define mock.On call +// - ctx context.Context +// - delAddr cosmos_sdktypes.AccAddress +// - valAddr cosmos_sdktypes.ValAddress +func (_e *DistributionKeeper_Expecter) WithdrawDelegationRewards(ctx interface{}, delAddr interface{}, valAddr interface{}) *DistributionKeeper_WithdrawDelegationRewards_Call { + return &DistributionKeeper_WithdrawDelegationRewards_Call{Call: _e.mock.On("WithdrawDelegationRewards", ctx, delAddr, valAddr)} +} + +func (_c *DistributionKeeper_WithdrawDelegationRewards_Call) Run(run func(ctx context.Context, delAddr cosmos_sdktypes.AccAddress, valAddr cosmos_sdktypes.ValAddress)) *DistributionKeeper_WithdrawDelegationRewards_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(cosmos_sdktypes.AccAddress), args[2].(cosmos_sdktypes.ValAddress)) + }) + return _c +} + +func (_c *DistributionKeeper_WithdrawDelegationRewards_Call) Return(_a0 cosmos_sdktypes.Coins, _a1 error) *DistributionKeeper_WithdrawDelegationRewards_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *DistributionKeeper_WithdrawDelegationRewards_Call) RunAndReturn(run func(context.Context, cosmos_sdktypes.AccAddress, cosmos_sdktypes.ValAddress) (cosmos_sdktypes.Coins, error)) *DistributionKeeper_WithdrawDelegationRewards_Call { + _c.Call.Return(run) + return _c +} + +// NewDistributionKeeper creates a new instance of DistributionKeeper. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewDistributionKeeper(t interface { + mock.TestingT + Cleanup(func()) +}, +) *DistributionKeeper { + mock := &DistributionKeeper{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/x/liquid/types/mocks/StakingKeeper.go b/x/liquid/types/mocks/StakingKeeper.go new file mode 100644 index 00000000..1e532cad --- /dev/null +++ b/x/liquid/types/mocks/StakingKeeper.go @@ -0,0 +1,953 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + context "context" + + address "cosmossdk.io/core/address" + + cosmos_sdktypes "github.com/cosmos/cosmos-sdk/types" + + math "cosmossdk.io/math" + + mock "github.com/stretchr/testify/mock" + + stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" +) + +// StakingKeeper is an autogenerated mock type for the StakingKeeper type +type StakingKeeper struct { + mock.Mock +} + +type StakingKeeper_Expecter struct { + mock *mock.Mock +} + +func (_m *StakingKeeper) EXPECT() *StakingKeeper_Expecter { + return &StakingKeeper_Expecter{mock: &_m.Mock} +} + +// BondDenom provides a mock function with given fields: ctx +func (_m *StakingKeeper) BondDenom(ctx context.Context) (string, error) { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for BondDenom") + } + + var r0 string + var r1 error + if rf, ok := ret.Get(0).(func(context.Context) (string, error)); ok { + return rf(ctx) + } + if rf, ok := ret.Get(0).(func(context.Context) string); ok { + r0 = rf(ctx) + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = rf(ctx) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// StakingKeeper_BondDenom_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BondDenom' +type StakingKeeper_BondDenom_Call struct { + *mock.Call +} + +// BondDenom is a helper method to define mock.On call +// - ctx context.Context +func (_e *StakingKeeper_Expecter) BondDenom(ctx interface{}) *StakingKeeper_BondDenom_Call { + return &StakingKeeper_BondDenom_Call{Call: _e.mock.On("BondDenom", ctx)} +} + +func (_c *StakingKeeper_BondDenom_Call) Run(run func(ctx context.Context)) *StakingKeeper_BondDenom_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *StakingKeeper_BondDenom_Call) Return(_a0 string, _a1 error) *StakingKeeper_BondDenom_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *StakingKeeper_BondDenom_Call) RunAndReturn(run func(context.Context) (string, error)) *StakingKeeper_BondDenom_Call { + _c.Call.Return(run) + return _c +} + +// Delegate provides a mock function with given fields: ctx, delAddr, bondAmt, tokenSrc, validator, subtractAccount +func (_m *StakingKeeper) Delegate(ctx context.Context, delAddr cosmos_sdktypes.AccAddress, bondAmt math.Int, tokenSrc stakingtypes.BondStatus, validator stakingtypes.Validator, subtractAccount bool) (math.LegacyDec, error) { + ret := _m.Called(ctx, delAddr, bondAmt, tokenSrc, validator, subtractAccount) + + if len(ret) == 0 { + panic("no return value specified for Delegate") + } + + var r0 math.LegacyDec + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, cosmos_sdktypes.AccAddress, math.Int, stakingtypes.BondStatus, stakingtypes.Validator, bool) (math.LegacyDec, error)); ok { + return rf(ctx, delAddr, bondAmt, tokenSrc, validator, subtractAccount) + } + if rf, ok := ret.Get(0).(func(context.Context, cosmos_sdktypes.AccAddress, math.Int, stakingtypes.BondStatus, stakingtypes.Validator, bool) math.LegacyDec); ok { + r0 = rf(ctx, delAddr, bondAmt, tokenSrc, validator, subtractAccount) + } else { + r0 = ret.Get(0).(math.LegacyDec) + } + + if rf, ok := ret.Get(1).(func(context.Context, cosmos_sdktypes.AccAddress, math.Int, stakingtypes.BondStatus, stakingtypes.Validator, bool) error); ok { + r1 = rf(ctx, delAddr, bondAmt, tokenSrc, validator, subtractAccount) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// StakingKeeper_Delegate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delegate' +type StakingKeeper_Delegate_Call struct { + *mock.Call +} + +// Delegate is a helper method to define mock.On call +// - ctx context.Context +// - delAddr cosmos_sdktypes.AccAddress +// - bondAmt math.Int +// - tokenSrc stakingtypes.BondStatus +// - validator stakingtypes.Validator +// - subtractAccount bool +func (_e *StakingKeeper_Expecter) Delegate(ctx interface{}, delAddr interface{}, bondAmt interface{}, tokenSrc interface{}, validator interface{}, subtractAccount interface{}) *StakingKeeper_Delegate_Call { + return &StakingKeeper_Delegate_Call{Call: _e.mock.On("Delegate", ctx, delAddr, bondAmt, tokenSrc, validator, subtractAccount)} +} + +func (_c *StakingKeeper_Delegate_Call) Run(run func(ctx context.Context, delAddr cosmos_sdktypes.AccAddress, bondAmt math.Int, tokenSrc stakingtypes.BondStatus, validator stakingtypes.Validator, subtractAccount bool)) *StakingKeeper_Delegate_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(cosmos_sdktypes.AccAddress), args[2].(math.Int), args[3].(stakingtypes.BondStatus), args[4].(stakingtypes.Validator), args[5].(bool)) + }) + return _c +} + +func (_c *StakingKeeper_Delegate_Call) Return(newShares math.LegacyDec, err error) *StakingKeeper_Delegate_Call { + _c.Call.Return(newShares, err) + return _c +} + +func (_c *StakingKeeper_Delegate_Call) RunAndReturn(run func(context.Context, cosmos_sdktypes.AccAddress, math.Int, stakingtypes.BondStatus, stakingtypes.Validator, bool) (math.LegacyDec, error)) *StakingKeeper_Delegate_Call { + _c.Call.Return(run) + return _c +} + +// Delegation provides a mock function with given fields: ctx, addrDel, addrVal +func (_m *StakingKeeper) Delegation(ctx context.Context, addrDel cosmos_sdktypes.AccAddress, addrVal cosmos_sdktypes.ValAddress) (stakingtypes.DelegationI, error) { + ret := _m.Called(ctx, addrDel, addrVal) + + if len(ret) == 0 { + panic("no return value specified for Delegation") + } + + var r0 stakingtypes.DelegationI + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, cosmos_sdktypes.AccAddress, cosmos_sdktypes.ValAddress) (stakingtypes.DelegationI, error)); ok { + return rf(ctx, addrDel, addrVal) + } + if rf, ok := ret.Get(0).(func(context.Context, cosmos_sdktypes.AccAddress, cosmos_sdktypes.ValAddress) stakingtypes.DelegationI); ok { + r0 = rf(ctx, addrDel, addrVal) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(stakingtypes.DelegationI) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, cosmos_sdktypes.AccAddress, cosmos_sdktypes.ValAddress) error); ok { + r1 = rf(ctx, addrDel, addrVal) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// StakingKeeper_Delegation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delegation' +type StakingKeeper_Delegation_Call struct { + *mock.Call +} + +// Delegation is a helper method to define mock.On call +// - ctx context.Context +// - addrDel cosmos_sdktypes.AccAddress +// - addrVal cosmos_sdktypes.ValAddress +func (_e *StakingKeeper_Expecter) Delegation(ctx interface{}, addrDel interface{}, addrVal interface{}) *StakingKeeper_Delegation_Call { + return &StakingKeeper_Delegation_Call{Call: _e.mock.On("Delegation", ctx, addrDel, addrVal)} +} + +func (_c *StakingKeeper_Delegation_Call) Run(run func(ctx context.Context, addrDel cosmos_sdktypes.AccAddress, addrVal cosmos_sdktypes.ValAddress)) *StakingKeeper_Delegation_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(cosmos_sdktypes.AccAddress), args[2].(cosmos_sdktypes.ValAddress)) + }) + return _c +} + +func (_c *StakingKeeper_Delegation_Call) Return(_a0 stakingtypes.DelegationI, _a1 error) *StakingKeeper_Delegation_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *StakingKeeper_Delegation_Call) RunAndReturn(run func(context.Context, cosmos_sdktypes.AccAddress, cosmos_sdktypes.ValAddress) (stakingtypes.DelegationI, error)) *StakingKeeper_Delegation_Call { + _c.Call.Return(run) + return _c +} + +// GetAllDelegations provides a mock function with given fields: ctx +func (_m *StakingKeeper) GetAllDelegations(ctx context.Context) ([]stakingtypes.Delegation, error) { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for GetAllDelegations") + } + + var r0 []stakingtypes.Delegation + var r1 error + if rf, ok := ret.Get(0).(func(context.Context) ([]stakingtypes.Delegation, error)); ok { + return rf(ctx) + } + if rf, ok := ret.Get(0).(func(context.Context) []stakingtypes.Delegation); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]stakingtypes.Delegation) + } + } + + if rf, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = rf(ctx) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// StakingKeeper_GetAllDelegations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllDelegations' +type StakingKeeper_GetAllDelegations_Call struct { + *mock.Call +} + +// GetAllDelegations is a helper method to define mock.On call +// - ctx context.Context +func (_e *StakingKeeper_Expecter) GetAllDelegations(ctx interface{}) *StakingKeeper_GetAllDelegations_Call { + return &StakingKeeper_GetAllDelegations_Call{Call: _e.mock.On("GetAllDelegations", ctx)} +} + +func (_c *StakingKeeper_GetAllDelegations_Call) Run(run func(ctx context.Context)) *StakingKeeper_GetAllDelegations_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *StakingKeeper_GetAllDelegations_Call) Return(delegations []stakingtypes.Delegation, err error) *StakingKeeper_GetAllDelegations_Call { + _c.Call.Return(delegations, err) + return _c +} + +func (_c *StakingKeeper_GetAllDelegations_Call) RunAndReturn(run func(context.Context) ([]stakingtypes.Delegation, error)) *StakingKeeper_GetAllDelegations_Call { + _c.Call.Return(run) + return _c +} + +// GetAllValidators provides a mock function with given fields: ctx +func (_m *StakingKeeper) GetAllValidators(ctx context.Context) ([]stakingtypes.Validator, error) { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for GetAllValidators") + } + + var r0 []stakingtypes.Validator + var r1 error + if rf, ok := ret.Get(0).(func(context.Context) ([]stakingtypes.Validator, error)); ok { + return rf(ctx) + } + if rf, ok := ret.Get(0).(func(context.Context) []stakingtypes.Validator); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]stakingtypes.Validator) + } + } + + if rf, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = rf(ctx) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// StakingKeeper_GetAllValidators_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllValidators' +type StakingKeeper_GetAllValidators_Call struct { + *mock.Call +} + +// GetAllValidators is a helper method to define mock.On call +// - ctx context.Context +func (_e *StakingKeeper_Expecter) GetAllValidators(ctx interface{}) *StakingKeeper_GetAllValidators_Call { + return &StakingKeeper_GetAllValidators_Call{Call: _e.mock.On("GetAllValidators", ctx)} +} + +func (_c *StakingKeeper_GetAllValidators_Call) Run(run func(ctx context.Context)) *StakingKeeper_GetAllValidators_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *StakingKeeper_GetAllValidators_Call) Return(validators []stakingtypes.Validator, err error) *StakingKeeper_GetAllValidators_Call { + _c.Call.Return(validators, err) + return _c +} + +func (_c *StakingKeeper_GetAllValidators_Call) RunAndReturn(run func(context.Context) ([]stakingtypes.Validator, error)) *StakingKeeper_GetAllValidators_Call { + _c.Call.Return(run) + return _c +} + +// GetDelegation provides a mock function with given fields: ctx, delAddr, valAddr +func (_m *StakingKeeper) GetDelegation(ctx context.Context, delAddr cosmos_sdktypes.AccAddress, valAddr cosmos_sdktypes.ValAddress) (stakingtypes.Delegation, error) { + ret := _m.Called(ctx, delAddr, valAddr) + + if len(ret) == 0 { + panic("no return value specified for GetDelegation") + } + + var r0 stakingtypes.Delegation + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, cosmos_sdktypes.AccAddress, cosmos_sdktypes.ValAddress) (stakingtypes.Delegation, error)); ok { + return rf(ctx, delAddr, valAddr) + } + if rf, ok := ret.Get(0).(func(context.Context, cosmos_sdktypes.AccAddress, cosmos_sdktypes.ValAddress) stakingtypes.Delegation); ok { + r0 = rf(ctx, delAddr, valAddr) + } else { + r0 = ret.Get(0).(stakingtypes.Delegation) + } + + if rf, ok := ret.Get(1).(func(context.Context, cosmos_sdktypes.AccAddress, cosmos_sdktypes.ValAddress) error); ok { + r1 = rf(ctx, delAddr, valAddr) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// StakingKeeper_GetDelegation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDelegation' +type StakingKeeper_GetDelegation_Call struct { + *mock.Call +} + +// GetDelegation is a helper method to define mock.On call +// - ctx context.Context +// - delAddr cosmos_sdktypes.AccAddress +// - valAddr cosmos_sdktypes.ValAddress +func (_e *StakingKeeper_Expecter) GetDelegation(ctx interface{}, delAddr interface{}, valAddr interface{}) *StakingKeeper_GetDelegation_Call { + return &StakingKeeper_GetDelegation_Call{Call: _e.mock.On("GetDelegation", ctx, delAddr, valAddr)} +} + +func (_c *StakingKeeper_GetDelegation_Call) Run(run func(ctx context.Context, delAddr cosmos_sdktypes.AccAddress, valAddr cosmos_sdktypes.ValAddress)) *StakingKeeper_GetDelegation_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(cosmos_sdktypes.AccAddress), args[2].(cosmos_sdktypes.ValAddress)) + }) + return _c +} + +func (_c *StakingKeeper_GetDelegation_Call) Return(_a0 stakingtypes.Delegation, _a1 error) *StakingKeeper_GetDelegation_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *StakingKeeper_GetDelegation_Call) RunAndReturn(run func(context.Context, cosmos_sdktypes.AccAddress, cosmos_sdktypes.ValAddress) (stakingtypes.Delegation, error)) *StakingKeeper_GetDelegation_Call { + _c.Call.Return(run) + return _c +} + +// GetParams provides a mock function with given fields: ctx +func (_m *StakingKeeper) GetParams(ctx context.Context) (stakingtypes.Params, error) { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for GetParams") + } + + var r0 stakingtypes.Params + var r1 error + if rf, ok := ret.Get(0).(func(context.Context) (stakingtypes.Params, error)); ok { + return rf(ctx) + } + if rf, ok := ret.Get(0).(func(context.Context) stakingtypes.Params); ok { + r0 = rf(ctx) + } else { + r0 = ret.Get(0).(stakingtypes.Params) + } + + if rf, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = rf(ctx) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// StakingKeeper_GetParams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetParams' +type StakingKeeper_GetParams_Call struct { + *mock.Call +} + +// GetParams is a helper method to define mock.On call +// - ctx context.Context +func (_e *StakingKeeper_Expecter) GetParams(ctx interface{}) *StakingKeeper_GetParams_Call { + return &StakingKeeper_GetParams_Call{Call: _e.mock.On("GetParams", ctx)} +} + +func (_c *StakingKeeper_GetParams_Call) Run(run func(ctx context.Context)) *StakingKeeper_GetParams_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *StakingKeeper_GetParams_Call) Return(params stakingtypes.Params, err error) *StakingKeeper_GetParams_Call { + _c.Call.Return(params, err) + return _c +} + +func (_c *StakingKeeper_GetParams_Call) RunAndReturn(run func(context.Context) (stakingtypes.Params, error)) *StakingKeeper_GetParams_Call { + _c.Call.Return(run) + return _c +} + +// GetValidator provides a mock function with given fields: ctx, addr +func (_m *StakingKeeper) GetValidator(ctx context.Context, addr cosmos_sdktypes.ValAddress) (stakingtypes.Validator, error) { + ret := _m.Called(ctx, addr) + + if len(ret) == 0 { + panic("no return value specified for GetValidator") + } + + var r0 stakingtypes.Validator + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, cosmos_sdktypes.ValAddress) (stakingtypes.Validator, error)); ok { + return rf(ctx, addr) + } + if rf, ok := ret.Get(0).(func(context.Context, cosmos_sdktypes.ValAddress) stakingtypes.Validator); ok { + r0 = rf(ctx, addr) + } else { + r0 = ret.Get(0).(stakingtypes.Validator) + } + + if rf, ok := ret.Get(1).(func(context.Context, cosmos_sdktypes.ValAddress) error); ok { + r1 = rf(ctx, addr) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// StakingKeeper_GetValidator_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetValidator' +type StakingKeeper_GetValidator_Call struct { + *mock.Call +} + +// GetValidator is a helper method to define mock.On call +// - ctx context.Context +// - addr cosmos_sdktypes.ValAddress +func (_e *StakingKeeper_Expecter) GetValidator(ctx interface{}, addr interface{}) *StakingKeeper_GetValidator_Call { + return &StakingKeeper_GetValidator_Call{Call: _e.mock.On("GetValidator", ctx, addr)} +} + +func (_c *StakingKeeper_GetValidator_Call) Run(run func(ctx context.Context, addr cosmos_sdktypes.ValAddress)) *StakingKeeper_GetValidator_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(cosmos_sdktypes.ValAddress)) + }) + return _c +} + +func (_c *StakingKeeper_GetValidator_Call) Return(validator stakingtypes.Validator, err error) *StakingKeeper_GetValidator_Call { + _c.Call.Return(validator, err) + return _c +} + +func (_c *StakingKeeper_GetValidator_Call) RunAndReturn(run func(context.Context, cosmos_sdktypes.ValAddress) (stakingtypes.Validator, error)) *StakingKeeper_GetValidator_Call { + _c.Call.Return(run) + return _c +} + +// GetValidatorDelegations provides a mock function with given fields: ctx, valAddr +func (_m *StakingKeeper) GetValidatorDelegations(ctx context.Context, valAddr cosmos_sdktypes.ValAddress) ([]stakingtypes.Delegation, error) { + ret := _m.Called(ctx, valAddr) + + if len(ret) == 0 { + panic("no return value specified for GetValidatorDelegations") + } + + var r0 []stakingtypes.Delegation + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, cosmos_sdktypes.ValAddress) ([]stakingtypes.Delegation, error)); ok { + return rf(ctx, valAddr) + } + if rf, ok := ret.Get(0).(func(context.Context, cosmos_sdktypes.ValAddress) []stakingtypes.Delegation); ok { + r0 = rf(ctx, valAddr) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]stakingtypes.Delegation) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, cosmos_sdktypes.ValAddress) error); ok { + r1 = rf(ctx, valAddr) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// StakingKeeper_GetValidatorDelegations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetValidatorDelegations' +type StakingKeeper_GetValidatorDelegations_Call struct { + *mock.Call +} + +// GetValidatorDelegations is a helper method to define mock.On call +// - ctx context.Context +// - valAddr cosmos_sdktypes.ValAddress +func (_e *StakingKeeper_Expecter) GetValidatorDelegations(ctx interface{}, valAddr interface{}) *StakingKeeper_GetValidatorDelegations_Call { + return &StakingKeeper_GetValidatorDelegations_Call{Call: _e.mock.On("GetValidatorDelegations", ctx, valAddr)} +} + +func (_c *StakingKeeper_GetValidatorDelegations_Call) Run(run func(ctx context.Context, valAddr cosmos_sdktypes.ValAddress)) *StakingKeeper_GetValidatorDelegations_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(cosmos_sdktypes.ValAddress)) + }) + return _c +} + +func (_c *StakingKeeper_GetValidatorDelegations_Call) Return(delegations []stakingtypes.Delegation, err error) *StakingKeeper_GetValidatorDelegations_Call { + _c.Call.Return(delegations, err) + return _c +} + +func (_c *StakingKeeper_GetValidatorDelegations_Call) RunAndReturn(run func(context.Context, cosmos_sdktypes.ValAddress) ([]stakingtypes.Delegation, error)) *StakingKeeper_GetValidatorDelegations_Call { + _c.Call.Return(run) + return _c +} + +// HasReceivingRedelegation provides a mock function with given fields: ctx, delAddr, valDstAddr +func (_m *StakingKeeper) HasReceivingRedelegation(ctx context.Context, delAddr cosmos_sdktypes.AccAddress, valDstAddr cosmos_sdktypes.ValAddress) (bool, error) { + ret := _m.Called(ctx, delAddr, valDstAddr) + + if len(ret) == 0 { + panic("no return value specified for HasReceivingRedelegation") + } + + var r0 bool + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, cosmos_sdktypes.AccAddress, cosmos_sdktypes.ValAddress) (bool, error)); ok { + return rf(ctx, delAddr, valDstAddr) + } + if rf, ok := ret.Get(0).(func(context.Context, cosmos_sdktypes.AccAddress, cosmos_sdktypes.ValAddress) bool); ok { + r0 = rf(ctx, delAddr, valDstAddr) + } else { + r0 = ret.Get(0).(bool) + } + + if rf, ok := ret.Get(1).(func(context.Context, cosmos_sdktypes.AccAddress, cosmos_sdktypes.ValAddress) error); ok { + r1 = rf(ctx, delAddr, valDstAddr) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// StakingKeeper_HasReceivingRedelegation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasReceivingRedelegation' +type StakingKeeper_HasReceivingRedelegation_Call struct { + *mock.Call +} + +// HasReceivingRedelegation is a helper method to define mock.On call +// - ctx context.Context +// - delAddr cosmos_sdktypes.AccAddress +// - valDstAddr cosmos_sdktypes.ValAddress +func (_e *StakingKeeper_Expecter) HasReceivingRedelegation(ctx interface{}, delAddr interface{}, valDstAddr interface{}) *StakingKeeper_HasReceivingRedelegation_Call { + return &StakingKeeper_HasReceivingRedelegation_Call{Call: _e.mock.On("HasReceivingRedelegation", ctx, delAddr, valDstAddr)} +} + +func (_c *StakingKeeper_HasReceivingRedelegation_Call) Run(run func(ctx context.Context, delAddr cosmos_sdktypes.AccAddress, valDstAddr cosmos_sdktypes.ValAddress)) *StakingKeeper_HasReceivingRedelegation_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(cosmos_sdktypes.AccAddress), args[2].(cosmos_sdktypes.ValAddress)) + }) + return _c +} + +func (_c *StakingKeeper_HasReceivingRedelegation_Call) Return(_a0 bool, _a1 error) *StakingKeeper_HasReceivingRedelegation_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *StakingKeeper_HasReceivingRedelegation_Call) RunAndReturn(run func(context.Context, cosmos_sdktypes.AccAddress, cosmos_sdktypes.ValAddress) (bool, error)) *StakingKeeper_HasReceivingRedelegation_Call { + _c.Call.Return(run) + return _c +} + +// SetValidator provides a mock function with given fields: ctx, validator +func (_m *StakingKeeper) SetValidator(ctx context.Context, validator stakingtypes.Validator) error { + ret := _m.Called(ctx, validator) + + if len(ret) == 0 { + panic("no return value specified for SetValidator") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, stakingtypes.Validator) error); ok { + r0 = rf(ctx, validator) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// StakingKeeper_SetValidator_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetValidator' +type StakingKeeper_SetValidator_Call struct { + *mock.Call +} + +// SetValidator is a helper method to define mock.On call +// - ctx context.Context +// - validator stakingtypes.Validator +func (_e *StakingKeeper_Expecter) SetValidator(ctx interface{}, validator interface{}) *StakingKeeper_SetValidator_Call { + return &StakingKeeper_SetValidator_Call{Call: _e.mock.On("SetValidator", ctx, validator)} +} + +func (_c *StakingKeeper_SetValidator_Call) Run(run func(ctx context.Context, validator stakingtypes.Validator)) *StakingKeeper_SetValidator_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(stakingtypes.Validator)) + }) + return _c +} + +func (_c *StakingKeeper_SetValidator_Call) Return(_a0 error) *StakingKeeper_SetValidator_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *StakingKeeper_SetValidator_Call) RunAndReturn(run func(context.Context, stakingtypes.Validator) error) *StakingKeeper_SetValidator_Call { + _c.Call.Return(run) + return _c +} + +// TotalBondedTokens provides a mock function with given fields: ctx +func (_m *StakingKeeper) TotalBondedTokens(ctx context.Context) (math.Int, error) { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for TotalBondedTokens") + } + + var r0 math.Int + var r1 error + if rf, ok := ret.Get(0).(func(context.Context) (math.Int, error)); ok { + return rf(ctx) + } + if rf, ok := ret.Get(0).(func(context.Context) math.Int); ok { + r0 = rf(ctx) + } else { + r0 = ret.Get(0).(math.Int) + } + + if rf, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = rf(ctx) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// StakingKeeper_TotalBondedTokens_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TotalBondedTokens' +type StakingKeeper_TotalBondedTokens_Call struct { + *mock.Call +} + +// TotalBondedTokens is a helper method to define mock.On call +// - ctx context.Context +func (_e *StakingKeeper_Expecter) TotalBondedTokens(ctx interface{}) *StakingKeeper_TotalBondedTokens_Call { + return &StakingKeeper_TotalBondedTokens_Call{Call: _e.mock.On("TotalBondedTokens", ctx)} +} + +func (_c *StakingKeeper_TotalBondedTokens_Call) Run(run func(ctx context.Context)) *StakingKeeper_TotalBondedTokens_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *StakingKeeper_TotalBondedTokens_Call) Return(_a0 math.Int, _a1 error) *StakingKeeper_TotalBondedTokens_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *StakingKeeper_TotalBondedTokens_Call) RunAndReturn(run func(context.Context) (math.Int, error)) *StakingKeeper_TotalBondedTokens_Call { + _c.Call.Return(run) + return _c +} + +// Unbond provides a mock function with given fields: ctx, delAddr, valAddr, shares +func (_m *StakingKeeper) Unbond(ctx context.Context, delAddr cosmos_sdktypes.AccAddress, valAddr cosmos_sdktypes.ValAddress, shares math.LegacyDec) (math.Int, error) { + ret := _m.Called(ctx, delAddr, valAddr, shares) + + if len(ret) == 0 { + panic("no return value specified for Unbond") + } + + var r0 math.Int + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, cosmos_sdktypes.AccAddress, cosmos_sdktypes.ValAddress, math.LegacyDec) (math.Int, error)); ok { + return rf(ctx, delAddr, valAddr, shares) + } + if rf, ok := ret.Get(0).(func(context.Context, cosmos_sdktypes.AccAddress, cosmos_sdktypes.ValAddress, math.LegacyDec) math.Int); ok { + r0 = rf(ctx, delAddr, valAddr, shares) + } else { + r0 = ret.Get(0).(math.Int) + } + + if rf, ok := ret.Get(1).(func(context.Context, cosmos_sdktypes.AccAddress, cosmos_sdktypes.ValAddress, math.LegacyDec) error); ok { + r1 = rf(ctx, delAddr, valAddr, shares) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// StakingKeeper_Unbond_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unbond' +type StakingKeeper_Unbond_Call struct { + *mock.Call +} + +// Unbond is a helper method to define mock.On call +// - ctx context.Context +// - delAddr cosmos_sdktypes.AccAddress +// - valAddr cosmos_sdktypes.ValAddress +// - shares math.LegacyDec +func (_e *StakingKeeper_Expecter) Unbond(ctx interface{}, delAddr interface{}, valAddr interface{}, shares interface{}) *StakingKeeper_Unbond_Call { + return &StakingKeeper_Unbond_Call{Call: _e.mock.On("Unbond", ctx, delAddr, valAddr, shares)} +} + +func (_c *StakingKeeper_Unbond_Call) Run(run func(ctx context.Context, delAddr cosmos_sdktypes.AccAddress, valAddr cosmos_sdktypes.ValAddress, shares math.LegacyDec)) *StakingKeeper_Unbond_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(cosmos_sdktypes.AccAddress), args[2].(cosmos_sdktypes.ValAddress), args[3].(math.LegacyDec)) + }) + return _c +} + +func (_c *StakingKeeper_Unbond_Call) Return(amount math.Int, err error) *StakingKeeper_Unbond_Call { + _c.Call.Return(amount, err) + return _c +} + +func (_c *StakingKeeper_Unbond_Call) RunAndReturn(run func(context.Context, cosmos_sdktypes.AccAddress, cosmos_sdktypes.ValAddress, math.LegacyDec) (math.Int, error)) *StakingKeeper_Unbond_Call { + _c.Call.Return(run) + return _c +} + +// ValidateUnbondAmount provides a mock function with given fields: ctx, delAddr, valAddr, amt +func (_m *StakingKeeper) ValidateUnbondAmount(ctx context.Context, delAddr cosmos_sdktypes.AccAddress, valAddr cosmos_sdktypes.ValAddress, amt math.Int) (math.LegacyDec, error) { + ret := _m.Called(ctx, delAddr, valAddr, amt) + + if len(ret) == 0 { + panic("no return value specified for ValidateUnbondAmount") + } + + var r0 math.LegacyDec + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, cosmos_sdktypes.AccAddress, cosmos_sdktypes.ValAddress, math.Int) (math.LegacyDec, error)); ok { + return rf(ctx, delAddr, valAddr, amt) + } + if rf, ok := ret.Get(0).(func(context.Context, cosmos_sdktypes.AccAddress, cosmos_sdktypes.ValAddress, math.Int) math.LegacyDec); ok { + r0 = rf(ctx, delAddr, valAddr, amt) + } else { + r0 = ret.Get(0).(math.LegacyDec) + } + + if rf, ok := ret.Get(1).(func(context.Context, cosmos_sdktypes.AccAddress, cosmos_sdktypes.ValAddress, math.Int) error); ok { + r1 = rf(ctx, delAddr, valAddr, amt) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// StakingKeeper_ValidateUnbondAmount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ValidateUnbondAmount' +type StakingKeeper_ValidateUnbondAmount_Call struct { + *mock.Call +} + +// ValidateUnbondAmount is a helper method to define mock.On call +// - ctx context.Context +// - delAddr cosmos_sdktypes.AccAddress +// - valAddr cosmos_sdktypes.ValAddress +// - amt math.Int +func (_e *StakingKeeper_Expecter) ValidateUnbondAmount(ctx interface{}, delAddr interface{}, valAddr interface{}, amt interface{}) *StakingKeeper_ValidateUnbondAmount_Call { + return &StakingKeeper_ValidateUnbondAmount_Call{Call: _e.mock.On("ValidateUnbondAmount", ctx, delAddr, valAddr, amt)} +} + +func (_c *StakingKeeper_ValidateUnbondAmount_Call) Run(run func(ctx context.Context, delAddr cosmos_sdktypes.AccAddress, valAddr cosmos_sdktypes.ValAddress, amt math.Int)) *StakingKeeper_ValidateUnbondAmount_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(cosmos_sdktypes.AccAddress), args[2].(cosmos_sdktypes.ValAddress), args[3].(math.Int)) + }) + return _c +} + +func (_c *StakingKeeper_ValidateUnbondAmount_Call) Return(shares math.LegacyDec, err error) *StakingKeeper_ValidateUnbondAmount_Call { + _c.Call.Return(shares, err) + return _c +} + +func (_c *StakingKeeper_ValidateUnbondAmount_Call) RunAndReturn(run func(context.Context, cosmos_sdktypes.AccAddress, cosmos_sdktypes.ValAddress, math.Int) (math.LegacyDec, error)) *StakingKeeper_ValidateUnbondAmount_Call { + _c.Call.Return(run) + return _c +} + +// Validator provides a mock function with given fields: ctx, _a1 +func (_m *StakingKeeper) Validator(ctx context.Context, _a1 cosmos_sdktypes.ValAddress) (stakingtypes.ValidatorI, error) { + ret := _m.Called(ctx, _a1) + + if len(ret) == 0 { + panic("no return value specified for Validator") + } + + var r0 stakingtypes.ValidatorI + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, cosmos_sdktypes.ValAddress) (stakingtypes.ValidatorI, error)); ok { + return rf(ctx, _a1) + } + if rf, ok := ret.Get(0).(func(context.Context, cosmos_sdktypes.ValAddress) stakingtypes.ValidatorI); ok { + r0 = rf(ctx, _a1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(stakingtypes.ValidatorI) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, cosmos_sdktypes.ValAddress) error); ok { + r1 = rf(ctx, _a1) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// StakingKeeper_Validator_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Validator' +type StakingKeeper_Validator_Call struct { + *mock.Call +} + +// Validator is a helper method to define mock.On call +// - ctx context.Context +// - _a1 cosmos_sdktypes.ValAddress +func (_e *StakingKeeper_Expecter) Validator(ctx interface{}, _a1 interface{}) *StakingKeeper_Validator_Call { + return &StakingKeeper_Validator_Call{Call: _e.mock.On("Validator", ctx, _a1)} +} + +func (_c *StakingKeeper_Validator_Call) Run(run func(ctx context.Context, _a1 cosmos_sdktypes.ValAddress)) *StakingKeeper_Validator_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(cosmos_sdktypes.ValAddress)) + }) + return _c +} + +func (_c *StakingKeeper_Validator_Call) Return(_a0 stakingtypes.ValidatorI, _a1 error) *StakingKeeper_Validator_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *StakingKeeper_Validator_Call) RunAndReturn(run func(context.Context, cosmos_sdktypes.ValAddress) (stakingtypes.ValidatorI, error)) *StakingKeeper_Validator_Call { + _c.Call.Return(run) + return _c +} + +// ValidatorAddressCodec provides a mock function with given fields: +func (_m *StakingKeeper) ValidatorAddressCodec() address.Codec { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for ValidatorAddressCodec") + } + + var r0 address.Codec + if rf, ok := ret.Get(0).(func() address.Codec); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(address.Codec) + } + } + + return r0 +} + +// StakingKeeper_ValidatorAddressCodec_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ValidatorAddressCodec' +type StakingKeeper_ValidatorAddressCodec_Call struct { + *mock.Call +} + +// ValidatorAddressCodec is a helper method to define mock.On call +func (_e *StakingKeeper_Expecter) ValidatorAddressCodec() *StakingKeeper_ValidatorAddressCodec_Call { + return &StakingKeeper_ValidatorAddressCodec_Call{Call: _e.mock.On("ValidatorAddressCodec")} +} + +func (_c *StakingKeeper_ValidatorAddressCodec_Call) Run(run func()) *StakingKeeper_ValidatorAddressCodec_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *StakingKeeper_ValidatorAddressCodec_Call) Return(_a0 address.Codec) *StakingKeeper_ValidatorAddressCodec_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *StakingKeeper_ValidatorAddressCodec_Call) RunAndReturn(run func() address.Codec) *StakingKeeper_ValidatorAddressCodec_Call { + _c.Call.Return(run) + return _c +} + +// NewStakingKeeper creates a new instance of StakingKeeper. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewStakingKeeper(t interface { + mock.TestingT + Cleanup(func()) +}, +) *StakingKeeper { + mock := &StakingKeeper{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/x/liquid/types/msg.go b/x/liquid/types/msg.go new file mode 100644 index 00000000..43a2286a --- /dev/null +++ b/x/liquid/types/msg.go @@ -0,0 +1,23 @@ +package types + +import ( + sdk "github.com/cosmos/cosmos-sdk/types" +) + +var ( + _ sdk.Msg = (*MsgWithdrawTokenizeShareRecordReward)(nil) + _ sdk.Msg = (*MsgWithdrawAllTokenizeShareRecordReward)(nil) +) + +func NewMsgWithdrawTokenizeShareRecordReward(ownerAddr string, recordID uint64) *MsgWithdrawTokenizeShareRecordReward { + return &MsgWithdrawTokenizeShareRecordReward{ + OwnerAddress: ownerAddr, + RecordId: recordID, + } +} + +func NewMsgWithdrawAllTokenizeShareRecordReward(ownerAddr string) *MsgWithdrawAllTokenizeShareRecordReward { + return &MsgWithdrawAllTokenizeShareRecordReward{ + OwnerAddress: ownerAddr, + } +} diff --git a/x/liquid/types/params.go b/x/liquid/types/params.go new file mode 100644 index 00000000..e50df784 --- /dev/null +++ b/x/liquid/types/params.go @@ -0,0 +1,97 @@ +package types + +import ( + "fmt" + + "cosmossdk.io/math" + + "github.com/cosmos/cosmos-sdk/codec" +) + +var ( + + // DefaultGlobalLiquidStakingCap is set to 100% + DefaultGlobalLiquidStakingCap = math.LegacyOneDec() + // DefaultValidatorLiquidStakingCap is set to 100% + DefaultValidatorLiquidStakingCap = math.LegacyOneDec() +) + +// NewParams creates a new Params instance +func NewParams( + globalLiquidStakingCap math.LegacyDec, + validatorLiquidStakingCap math.LegacyDec, +) Params { + return Params{ + GlobalLiquidStakingCap: globalLiquidStakingCap, + ValidatorLiquidStakingCap: validatorLiquidStakingCap, + } +} + +// DefaultParams returns a default set of parameters. +func DefaultParams() Params { + return NewParams( + DefaultGlobalLiquidStakingCap, + DefaultValidatorLiquidStakingCap, + ) +} + +// unmarshal the current liquid params value from store key or panic +func MustUnmarshalParams(cdc *codec.LegacyAmino, value []byte) Params { + params, err := UnmarshalParams(cdc, value) + if err != nil { + panic(err) + } + + return params +} + +// unmarshal the current liquid params value from store key +func UnmarshalParams(cdc *codec.LegacyAmino, value []byte) (params Params, err error) { + err = cdc.Unmarshal(value, ¶ms) + if err != nil { + return + } + + return +} + +// validate a set of params +func (p Params) Validate() error { + if err := validateGlobalLiquidStakingCap(p.GlobalLiquidStakingCap); err != nil { + return err + } + + return validateValidatorLiquidStakingCap(p.ValidatorLiquidStakingCap) +} + +func validateGlobalLiquidStakingCap(i interface{}) error { + v, ok := i.(math.LegacyDec) + if !ok { + return fmt.Errorf("invalid parameter type: %T", i) + } + + if v.IsNegative() { + return fmt.Errorf("global liquid staking cap cannot be negative: %s", v) + } + if v.GT(math.LegacyOneDec()) { + return fmt.Errorf("global liquid staking cap cannot be greater than 100%%: %s", v) + } + + return nil +} + +func validateValidatorLiquidStakingCap(i interface{}) error { + v, ok := i.(math.LegacyDec) + if !ok { + return fmt.Errorf("invalid parameter type: %T", i) + } + + if v.IsNegative() { + return fmt.Errorf("validator liquid staking cap cannot be negative: %s", v) + } + if v.GT(math.LegacyOneDec()) { + return fmt.Errorf("validator liquid staking cap cannot be greater than 100%%: %s", v) + } + + return nil +} diff --git a/x/liquid/types/query.pb.go b/x/liquid/types/query.pb.go new file mode 100644 index 00000000..ef2c8011 --- /dev/null +++ b/x/liquid/types/query.pb.go @@ -0,0 +1,4945 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: kyve/liquid/v1beta1/query.proto + +package types + +import ( + context "context" + fmt "fmt" + github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" + types "github.com/cosmos/cosmos-sdk/types" + query "github.com/cosmos/cosmos-sdk/types/query" + _ "github.com/cosmos/cosmos-sdk/types/tx/amino" + _ "github.com/cosmos/gogoproto/gogoproto" + grpc1 "github.com/cosmos/gogoproto/grpc" + proto "github.com/cosmos/gogoproto/proto" + _ "google.golang.org/genproto/googleapis/api/annotations" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +// QueryLiquidValidatorRequest is the request type for the Query/LiquidValidator +// RPC method. +type QueryLiquidValidatorRequest struct { + ValidatorAddr string `protobuf:"bytes,1,opt,name=validator_addr,json=validatorAddr,proto3" json:"validator_addr,omitempty"` +} + +func (m *QueryLiquidValidatorRequest) Reset() { *m = QueryLiquidValidatorRequest{} } +func (m *QueryLiquidValidatorRequest) String() string { return proto.CompactTextString(m) } +func (*QueryLiquidValidatorRequest) ProtoMessage() {} +func (*QueryLiquidValidatorRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_1a9d927347bb19fc, []int{0} +} +func (m *QueryLiquidValidatorRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryLiquidValidatorRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryLiquidValidatorRequest.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 *QueryLiquidValidatorRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryLiquidValidatorRequest.Merge(m, src) +} +func (m *QueryLiquidValidatorRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryLiquidValidatorRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryLiquidValidatorRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryLiquidValidatorRequest proto.InternalMessageInfo + +func (m *QueryLiquidValidatorRequest) GetValidatorAddr() string { + if m != nil { + return m.ValidatorAddr + } + return "" +} + +// QueryLiquidValidatorResponse is the response type for the +// Query/LiquidValidator RPC method. +type QueryLiquidValidatorResponse struct { + LiquidValidator LiquidValidator `protobuf:"bytes,1,opt,name=liquid_validator,json=liquidValidator,proto3" json:"liquid_validator"` +} + +func (m *QueryLiquidValidatorResponse) Reset() { *m = QueryLiquidValidatorResponse{} } +func (m *QueryLiquidValidatorResponse) String() string { return proto.CompactTextString(m) } +func (*QueryLiquidValidatorResponse) ProtoMessage() {} +func (*QueryLiquidValidatorResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_1a9d927347bb19fc, []int{1} +} +func (m *QueryLiquidValidatorResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryLiquidValidatorResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryLiquidValidatorResponse.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 *QueryLiquidValidatorResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryLiquidValidatorResponse.Merge(m, src) +} +func (m *QueryLiquidValidatorResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryLiquidValidatorResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryLiquidValidatorResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryLiquidValidatorResponse proto.InternalMessageInfo + +func (m *QueryLiquidValidatorResponse) GetLiquidValidator() LiquidValidator { + if m != nil { + return m.LiquidValidator + } + return LiquidValidator{} +} + +// QueryLiquidValidatorsRequest is request type for the +// Query/QueryLiquidValidators RPC method. +type QueryLiquidValidatorsRequest struct { + // pagination defines an optional pagination for the request. + Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"` +} + +func (m *QueryLiquidValidatorsRequest) Reset() { *m = QueryLiquidValidatorsRequest{} } +func (m *QueryLiquidValidatorsRequest) String() string { return proto.CompactTextString(m) } +func (*QueryLiquidValidatorsRequest) ProtoMessage() {} +func (*QueryLiquidValidatorsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_1a9d927347bb19fc, []int{2} +} +func (m *QueryLiquidValidatorsRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryLiquidValidatorsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryLiquidValidatorsRequest.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 *QueryLiquidValidatorsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryLiquidValidatorsRequest.Merge(m, src) +} +func (m *QueryLiquidValidatorsRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryLiquidValidatorsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryLiquidValidatorsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryLiquidValidatorsRequest proto.InternalMessageInfo + +func (m *QueryLiquidValidatorsRequest) GetPagination() *query.PageRequest { + if m != nil { + return m.Pagination + } + return nil +} + +// QueryLiquidValidatorsResponse is response type for the +// Query/QueryLiquidValidators RPC method. +type QueryLiquidValidatorsResponse struct { + LiquidValidators []LiquidValidator `protobuf:"bytes,1,rep,name=liquid_validators,json=liquidValidators,proto3" json:"liquid_validators"` + // pagination defines the pagination in the response. + Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"` +} + +func (m *QueryLiquidValidatorsResponse) Reset() { *m = QueryLiquidValidatorsResponse{} } +func (m *QueryLiquidValidatorsResponse) String() string { return proto.CompactTextString(m) } +func (*QueryLiquidValidatorsResponse) ProtoMessage() {} +func (*QueryLiquidValidatorsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_1a9d927347bb19fc, []int{3} +} +func (m *QueryLiquidValidatorsResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryLiquidValidatorsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryLiquidValidatorsResponse.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 *QueryLiquidValidatorsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryLiquidValidatorsResponse.Merge(m, src) +} +func (m *QueryLiquidValidatorsResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryLiquidValidatorsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryLiquidValidatorsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryLiquidValidatorsResponse proto.InternalMessageInfo + +func (m *QueryLiquidValidatorsResponse) GetLiquidValidators() []LiquidValidator { + if m != nil { + return m.LiquidValidators + } + return nil +} + +func (m *QueryLiquidValidatorsResponse) GetPagination() *query.PageResponse { + if m != nil { + return m.Pagination + } + return nil +} + +// QueryParamsRequest is request type for the Query/Params RPC method. +type QueryParamsRequest struct { +} + +func (m *QueryParamsRequest) Reset() { *m = QueryParamsRequest{} } +func (m *QueryParamsRequest) String() string { return proto.CompactTextString(m) } +func (*QueryParamsRequest) ProtoMessage() {} +func (*QueryParamsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_1a9d927347bb19fc, []int{4} +} +func (m *QueryParamsRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryParamsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryParamsRequest.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 *QueryParamsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryParamsRequest.Merge(m, src) +} +func (m *QueryParamsRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryParamsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryParamsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryParamsRequest proto.InternalMessageInfo + +// QueryParamsResponse is response type for the Query/Params RPC method. +type QueryParamsResponse struct { + // params holds all the parameters of this module. + Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"` +} + +func (m *QueryParamsResponse) Reset() { *m = QueryParamsResponse{} } +func (m *QueryParamsResponse) String() string { return proto.CompactTextString(m) } +func (*QueryParamsResponse) ProtoMessage() {} +func (*QueryParamsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_1a9d927347bb19fc, []int{5} +} +func (m *QueryParamsResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryParamsResponse.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 *QueryParamsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryParamsResponse.Merge(m, src) +} +func (m *QueryParamsResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryParamsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryParamsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryParamsResponse proto.InternalMessageInfo + +func (m *QueryParamsResponse) GetParams() Params { + if m != nil { + return m.Params + } + return Params{} +} + +// QueryTokenizeShareRecordByIdRequest is request type for the +// Query/QueryTokenizeShareRecordById RPC method. +type QueryTokenizeShareRecordByIdRequest struct { + Id uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` +} + +func (m *QueryTokenizeShareRecordByIdRequest) Reset() { *m = QueryTokenizeShareRecordByIdRequest{} } +func (m *QueryTokenizeShareRecordByIdRequest) String() string { return proto.CompactTextString(m) } +func (*QueryTokenizeShareRecordByIdRequest) ProtoMessage() {} +func (*QueryTokenizeShareRecordByIdRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_1a9d927347bb19fc, []int{6} +} +func (m *QueryTokenizeShareRecordByIdRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryTokenizeShareRecordByIdRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryTokenizeShareRecordByIdRequest.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 *QueryTokenizeShareRecordByIdRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryTokenizeShareRecordByIdRequest.Merge(m, src) +} +func (m *QueryTokenizeShareRecordByIdRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryTokenizeShareRecordByIdRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryTokenizeShareRecordByIdRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryTokenizeShareRecordByIdRequest proto.InternalMessageInfo + +func (m *QueryTokenizeShareRecordByIdRequest) GetId() uint64 { + if m != nil { + return m.Id + } + return 0 +} + +// QueryTokenizeShareRecordByIdRequest is response type for the +// Query/QueryTokenizeShareRecordById RPC method. +type QueryTokenizeShareRecordByIdResponse struct { + Record TokenizeShareRecord `protobuf:"bytes,1,opt,name=record,proto3" json:"record"` +} + +func (m *QueryTokenizeShareRecordByIdResponse) Reset() { *m = QueryTokenizeShareRecordByIdResponse{} } +func (m *QueryTokenizeShareRecordByIdResponse) String() string { return proto.CompactTextString(m) } +func (*QueryTokenizeShareRecordByIdResponse) ProtoMessage() {} +func (*QueryTokenizeShareRecordByIdResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_1a9d927347bb19fc, []int{7} +} +func (m *QueryTokenizeShareRecordByIdResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryTokenizeShareRecordByIdResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryTokenizeShareRecordByIdResponse.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 *QueryTokenizeShareRecordByIdResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryTokenizeShareRecordByIdResponse.Merge(m, src) +} +func (m *QueryTokenizeShareRecordByIdResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryTokenizeShareRecordByIdResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryTokenizeShareRecordByIdResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryTokenizeShareRecordByIdResponse proto.InternalMessageInfo + +func (m *QueryTokenizeShareRecordByIdResponse) GetRecord() TokenizeShareRecord { + if m != nil { + return m.Record + } + return TokenizeShareRecord{} +} + +// QueryTokenizeShareRecordByDenomRequest is request type for the +// Query/QueryTokenizeShareRecordByDenom RPC method. +type QueryTokenizeShareRecordByDenomRequest struct { + Denom string `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty"` +} + +func (m *QueryTokenizeShareRecordByDenomRequest) Reset() { + *m = QueryTokenizeShareRecordByDenomRequest{} +} +func (m *QueryTokenizeShareRecordByDenomRequest) String() string { return proto.CompactTextString(m) } +func (*QueryTokenizeShareRecordByDenomRequest) ProtoMessage() {} +func (*QueryTokenizeShareRecordByDenomRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_1a9d927347bb19fc, []int{8} +} +func (m *QueryTokenizeShareRecordByDenomRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryTokenizeShareRecordByDenomRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryTokenizeShareRecordByDenomRequest.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 *QueryTokenizeShareRecordByDenomRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryTokenizeShareRecordByDenomRequest.Merge(m, src) +} +func (m *QueryTokenizeShareRecordByDenomRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryTokenizeShareRecordByDenomRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryTokenizeShareRecordByDenomRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryTokenizeShareRecordByDenomRequest proto.InternalMessageInfo + +func (m *QueryTokenizeShareRecordByDenomRequest) GetDenom() string { + if m != nil { + return m.Denom + } + return "" +} + +// QueryTokenizeShareRecordByDenomResponse is response type for the +// Query/QueryTokenizeShareRecordByDenom RPC method. +type QueryTokenizeShareRecordByDenomResponse struct { + Record TokenizeShareRecord `protobuf:"bytes,1,opt,name=record,proto3" json:"record"` +} + +func (m *QueryTokenizeShareRecordByDenomResponse) Reset() { + *m = QueryTokenizeShareRecordByDenomResponse{} +} +func (m *QueryTokenizeShareRecordByDenomResponse) String() string { return proto.CompactTextString(m) } +func (*QueryTokenizeShareRecordByDenomResponse) ProtoMessage() {} +func (*QueryTokenizeShareRecordByDenomResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_1a9d927347bb19fc, []int{9} +} +func (m *QueryTokenizeShareRecordByDenomResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryTokenizeShareRecordByDenomResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryTokenizeShareRecordByDenomResponse.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 *QueryTokenizeShareRecordByDenomResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryTokenizeShareRecordByDenomResponse.Merge(m, src) +} +func (m *QueryTokenizeShareRecordByDenomResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryTokenizeShareRecordByDenomResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryTokenizeShareRecordByDenomResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryTokenizeShareRecordByDenomResponse proto.InternalMessageInfo + +func (m *QueryTokenizeShareRecordByDenomResponse) GetRecord() TokenizeShareRecord { + if m != nil { + return m.Record + } + return TokenizeShareRecord{} +} + +// QueryTokenizeShareRecordsOwnedRequest is request type for the +// Query/QueryTokenizeShareRecordsOwned RPC method. +type QueryTokenizeShareRecordsOwnedRequest struct { + Owner string `protobuf:"bytes,1,opt,name=owner,proto3" json:"owner,omitempty"` +} + +func (m *QueryTokenizeShareRecordsOwnedRequest) Reset() { *m = QueryTokenizeShareRecordsOwnedRequest{} } +func (m *QueryTokenizeShareRecordsOwnedRequest) String() string { return proto.CompactTextString(m) } +func (*QueryTokenizeShareRecordsOwnedRequest) ProtoMessage() {} +func (*QueryTokenizeShareRecordsOwnedRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_1a9d927347bb19fc, []int{10} +} +func (m *QueryTokenizeShareRecordsOwnedRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryTokenizeShareRecordsOwnedRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryTokenizeShareRecordsOwnedRequest.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 *QueryTokenizeShareRecordsOwnedRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryTokenizeShareRecordsOwnedRequest.Merge(m, src) +} +func (m *QueryTokenizeShareRecordsOwnedRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryTokenizeShareRecordsOwnedRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryTokenizeShareRecordsOwnedRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryTokenizeShareRecordsOwnedRequest proto.InternalMessageInfo + +func (m *QueryTokenizeShareRecordsOwnedRequest) GetOwner() string { + if m != nil { + return m.Owner + } + return "" +} + +// QueryTokenizeShareRecordsOwnedResponse is response type for the +// Query/QueryTokenizeShareRecordsOwned RPC method. +type QueryTokenizeShareRecordsOwnedResponse struct { + Records []TokenizeShareRecord `protobuf:"bytes,1,rep,name=records,proto3" json:"records"` +} + +func (m *QueryTokenizeShareRecordsOwnedResponse) Reset() { + *m = QueryTokenizeShareRecordsOwnedResponse{} +} +func (m *QueryTokenizeShareRecordsOwnedResponse) String() string { return proto.CompactTextString(m) } +func (*QueryTokenizeShareRecordsOwnedResponse) ProtoMessage() {} +func (*QueryTokenizeShareRecordsOwnedResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_1a9d927347bb19fc, []int{11} +} +func (m *QueryTokenizeShareRecordsOwnedResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryTokenizeShareRecordsOwnedResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryTokenizeShareRecordsOwnedResponse.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 *QueryTokenizeShareRecordsOwnedResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryTokenizeShareRecordsOwnedResponse.Merge(m, src) +} +func (m *QueryTokenizeShareRecordsOwnedResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryTokenizeShareRecordsOwnedResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryTokenizeShareRecordsOwnedResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryTokenizeShareRecordsOwnedResponse proto.InternalMessageInfo + +func (m *QueryTokenizeShareRecordsOwnedResponse) GetRecords() []TokenizeShareRecord { + if m != nil { + return m.Records + } + return nil +} + +// QueryAllTokenizeShareRecordsRequest is request type for the +// Query/QueryAllTokenizeShareRecords RPC method. +type QueryAllTokenizeShareRecordsRequest struct { + // pagination defines an optional pagination for the request. + Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"` +} + +func (m *QueryAllTokenizeShareRecordsRequest) Reset() { *m = QueryAllTokenizeShareRecordsRequest{} } +func (m *QueryAllTokenizeShareRecordsRequest) String() string { return proto.CompactTextString(m) } +func (*QueryAllTokenizeShareRecordsRequest) ProtoMessage() {} +func (*QueryAllTokenizeShareRecordsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_1a9d927347bb19fc, []int{12} +} +func (m *QueryAllTokenizeShareRecordsRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryAllTokenizeShareRecordsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryAllTokenizeShareRecordsRequest.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 *QueryAllTokenizeShareRecordsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryAllTokenizeShareRecordsRequest.Merge(m, src) +} +func (m *QueryAllTokenizeShareRecordsRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryAllTokenizeShareRecordsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryAllTokenizeShareRecordsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryAllTokenizeShareRecordsRequest proto.InternalMessageInfo + +func (m *QueryAllTokenizeShareRecordsRequest) GetPagination() *query.PageRequest { + if m != nil { + return m.Pagination + } + return nil +} + +// QueryAllTokenizeShareRecordsResponse is response type for the +// Query/QueryAllTokenizeShareRecords RPC method. +type QueryAllTokenizeShareRecordsResponse struct { + Records []TokenizeShareRecord `protobuf:"bytes,1,rep,name=records,proto3" json:"records"` + // pagination defines the pagination in the response. + Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"` +} + +func (m *QueryAllTokenizeShareRecordsResponse) Reset() { *m = QueryAllTokenizeShareRecordsResponse{} } +func (m *QueryAllTokenizeShareRecordsResponse) String() string { return proto.CompactTextString(m) } +func (*QueryAllTokenizeShareRecordsResponse) ProtoMessage() {} +func (*QueryAllTokenizeShareRecordsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_1a9d927347bb19fc, []int{13} +} +func (m *QueryAllTokenizeShareRecordsResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryAllTokenizeShareRecordsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryAllTokenizeShareRecordsResponse.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 *QueryAllTokenizeShareRecordsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryAllTokenizeShareRecordsResponse.Merge(m, src) +} +func (m *QueryAllTokenizeShareRecordsResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryAllTokenizeShareRecordsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryAllTokenizeShareRecordsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryAllTokenizeShareRecordsResponse proto.InternalMessageInfo + +func (m *QueryAllTokenizeShareRecordsResponse) GetRecords() []TokenizeShareRecord { + if m != nil { + return m.Records + } + return nil +} + +func (m *QueryAllTokenizeShareRecordsResponse) GetPagination() *query.PageResponse { + if m != nil { + return m.Pagination + } + return nil +} + +// QueryLastTokenizeShareRecordIdRequest is request type for the +// Query/QueryLastTokenizeShareRecordId RPC method. +type QueryLastTokenizeShareRecordIdRequest struct { +} + +func (m *QueryLastTokenizeShareRecordIdRequest) Reset() { *m = QueryLastTokenizeShareRecordIdRequest{} } +func (m *QueryLastTokenizeShareRecordIdRequest) String() string { return proto.CompactTextString(m) } +func (*QueryLastTokenizeShareRecordIdRequest) ProtoMessage() {} +func (*QueryLastTokenizeShareRecordIdRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_1a9d927347bb19fc, []int{14} +} +func (m *QueryLastTokenizeShareRecordIdRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryLastTokenizeShareRecordIdRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryLastTokenizeShareRecordIdRequest.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 *QueryLastTokenizeShareRecordIdRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryLastTokenizeShareRecordIdRequest.Merge(m, src) +} +func (m *QueryLastTokenizeShareRecordIdRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryLastTokenizeShareRecordIdRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryLastTokenizeShareRecordIdRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryLastTokenizeShareRecordIdRequest proto.InternalMessageInfo + +// QueryLastTokenizeShareRecordIdResponse is response type for the +// Query/QueryLastTokenizeShareRecordId RPC method. +type QueryLastTokenizeShareRecordIdResponse struct { + Id uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` +} + +func (m *QueryLastTokenizeShareRecordIdResponse) Reset() { + *m = QueryLastTokenizeShareRecordIdResponse{} +} +func (m *QueryLastTokenizeShareRecordIdResponse) String() string { return proto.CompactTextString(m) } +func (*QueryLastTokenizeShareRecordIdResponse) ProtoMessage() {} +func (*QueryLastTokenizeShareRecordIdResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_1a9d927347bb19fc, []int{15} +} +func (m *QueryLastTokenizeShareRecordIdResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryLastTokenizeShareRecordIdResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryLastTokenizeShareRecordIdResponse.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 *QueryLastTokenizeShareRecordIdResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryLastTokenizeShareRecordIdResponse.Merge(m, src) +} +func (m *QueryLastTokenizeShareRecordIdResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryLastTokenizeShareRecordIdResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryLastTokenizeShareRecordIdResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryLastTokenizeShareRecordIdResponse proto.InternalMessageInfo + +func (m *QueryLastTokenizeShareRecordIdResponse) GetId() uint64 { + if m != nil { + return m.Id + } + return 0 +} + +// QueryTotalTokenizeSharedAssetsRequest is request type for the +// Query/QueryTotalTokenizeSharedAssets RPC method. +type QueryTotalTokenizeSharedAssetsRequest struct { +} + +func (m *QueryTotalTokenizeSharedAssetsRequest) Reset() { *m = QueryTotalTokenizeSharedAssetsRequest{} } +func (m *QueryTotalTokenizeSharedAssetsRequest) String() string { return proto.CompactTextString(m) } +func (*QueryTotalTokenizeSharedAssetsRequest) ProtoMessage() {} +func (*QueryTotalTokenizeSharedAssetsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_1a9d927347bb19fc, []int{16} +} +func (m *QueryTotalTokenizeSharedAssetsRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryTotalTokenizeSharedAssetsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryTotalTokenizeSharedAssetsRequest.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 *QueryTotalTokenizeSharedAssetsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryTotalTokenizeSharedAssetsRequest.Merge(m, src) +} +func (m *QueryTotalTokenizeSharedAssetsRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryTotalTokenizeSharedAssetsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryTotalTokenizeSharedAssetsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryTotalTokenizeSharedAssetsRequest proto.InternalMessageInfo + +// QueryTotalTokenizeSharedAssetsResponse is response type for the +// Query/QueryTotalTokenizeSharedAssets RPC method. +type QueryTotalTokenizeSharedAssetsResponse struct { + Value types.Coin `protobuf:"bytes,1,opt,name=value,proto3" json:"value"` +} + +func (m *QueryTotalTokenizeSharedAssetsResponse) Reset() { + *m = QueryTotalTokenizeSharedAssetsResponse{} +} +func (m *QueryTotalTokenizeSharedAssetsResponse) String() string { return proto.CompactTextString(m) } +func (*QueryTotalTokenizeSharedAssetsResponse) ProtoMessage() {} +func (*QueryTotalTokenizeSharedAssetsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_1a9d927347bb19fc, []int{17} +} +func (m *QueryTotalTokenizeSharedAssetsResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryTotalTokenizeSharedAssetsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryTotalTokenizeSharedAssetsResponse.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 *QueryTotalTokenizeSharedAssetsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryTotalTokenizeSharedAssetsResponse.Merge(m, src) +} +func (m *QueryTotalTokenizeSharedAssetsResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryTotalTokenizeSharedAssetsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryTotalTokenizeSharedAssetsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryTotalTokenizeSharedAssetsResponse proto.InternalMessageInfo + +func (m *QueryTotalTokenizeSharedAssetsResponse) GetValue() types.Coin { + if m != nil { + return m.Value + } + return types.Coin{} +} + +// QueryTotalLiquidStakedRequest is request type for the +// Query/QueryQueryTotalLiquidStaked RPC method. +type QueryTotalLiquidStaked struct { +} + +func (m *QueryTotalLiquidStaked) Reset() { *m = QueryTotalLiquidStaked{} } +func (m *QueryTotalLiquidStaked) String() string { return proto.CompactTextString(m) } +func (*QueryTotalLiquidStaked) ProtoMessage() {} +func (*QueryTotalLiquidStaked) Descriptor() ([]byte, []int) { + return fileDescriptor_1a9d927347bb19fc, []int{18} +} +func (m *QueryTotalLiquidStaked) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryTotalLiquidStaked) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryTotalLiquidStaked.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 *QueryTotalLiquidStaked) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryTotalLiquidStaked.Merge(m, src) +} +func (m *QueryTotalLiquidStaked) XXX_Size() int { + return m.Size() +} +func (m *QueryTotalLiquidStaked) XXX_DiscardUnknown() { + xxx_messageInfo_QueryTotalLiquidStaked.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryTotalLiquidStaked proto.InternalMessageInfo + +// QueryTotalLiquidStakedResponse is response type for the +// Query/QueryQueryTotalLiquidStaked RPC method. +type QueryTotalLiquidStakedResponse struct { + Tokens string `protobuf:"bytes,1,opt,name=tokens,proto3" json:"tokens,omitempty"` +} + +func (m *QueryTotalLiquidStakedResponse) Reset() { *m = QueryTotalLiquidStakedResponse{} } +func (m *QueryTotalLiquidStakedResponse) String() string { return proto.CompactTextString(m) } +func (*QueryTotalLiquidStakedResponse) ProtoMessage() {} +func (*QueryTotalLiquidStakedResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_1a9d927347bb19fc, []int{19} +} +func (m *QueryTotalLiquidStakedResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryTotalLiquidStakedResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryTotalLiquidStakedResponse.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 *QueryTotalLiquidStakedResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryTotalLiquidStakedResponse.Merge(m, src) +} +func (m *QueryTotalLiquidStakedResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryTotalLiquidStakedResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryTotalLiquidStakedResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryTotalLiquidStakedResponse proto.InternalMessageInfo + +func (m *QueryTotalLiquidStakedResponse) GetTokens() string { + if m != nil { + return m.Tokens + } + return "" +} + +// QueryTokenizeShareLockInfo queries the tokenize share lock information +// associated with given account +type QueryTokenizeShareLockInfo struct { + Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` +} + +func (m *QueryTokenizeShareLockInfo) Reset() { *m = QueryTokenizeShareLockInfo{} } +func (m *QueryTokenizeShareLockInfo) String() string { return proto.CompactTextString(m) } +func (*QueryTokenizeShareLockInfo) ProtoMessage() {} +func (*QueryTokenizeShareLockInfo) Descriptor() ([]byte, []int) { + return fileDescriptor_1a9d927347bb19fc, []int{20} +} +func (m *QueryTokenizeShareLockInfo) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryTokenizeShareLockInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryTokenizeShareLockInfo.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 *QueryTokenizeShareLockInfo) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryTokenizeShareLockInfo.Merge(m, src) +} +func (m *QueryTokenizeShareLockInfo) XXX_Size() int { + return m.Size() +} +func (m *QueryTokenizeShareLockInfo) XXX_DiscardUnknown() { + xxx_messageInfo_QueryTokenizeShareLockInfo.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryTokenizeShareLockInfo proto.InternalMessageInfo + +func (m *QueryTokenizeShareLockInfo) GetAddress() string { + if m != nil { + return m.Address + } + return "" +} + +// QueryTokenizeShareLockInfoResponse is the response from the +// QueryTokenizeShareLockInfo query +type QueryTokenizeShareLockInfoResponse struct { + Status string `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"` + ExpirationTime string `protobuf:"bytes,2,opt,name=expiration_time,json=expirationTime,proto3" json:"expiration_time,omitempty"` +} + +func (m *QueryTokenizeShareLockInfoResponse) Reset() { *m = QueryTokenizeShareLockInfoResponse{} } +func (m *QueryTokenizeShareLockInfoResponse) String() string { return proto.CompactTextString(m) } +func (*QueryTokenizeShareLockInfoResponse) ProtoMessage() {} +func (*QueryTokenizeShareLockInfoResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_1a9d927347bb19fc, []int{21} +} +func (m *QueryTokenizeShareLockInfoResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryTokenizeShareLockInfoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryTokenizeShareLockInfoResponse.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 *QueryTokenizeShareLockInfoResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryTokenizeShareLockInfoResponse.Merge(m, src) +} +func (m *QueryTokenizeShareLockInfoResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryTokenizeShareLockInfoResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryTokenizeShareLockInfoResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryTokenizeShareLockInfoResponse proto.InternalMessageInfo + +func (m *QueryTokenizeShareLockInfoResponse) GetStatus() string { + if m != nil { + return m.Status + } + return "" +} + +func (m *QueryTokenizeShareLockInfoResponse) GetExpirationTime() string { + if m != nil { + return m.ExpirationTime + } + return "" +} + +// QueryTokenizeShareRecordRewardRequest is the request type for the +// Query/TokenizeShareRecordReward RPC method. +type QueryTokenizeShareRecordRewardRequest struct { + OwnerAddress string `protobuf:"bytes,1,opt,name=owner_address,json=ownerAddress,proto3" json:"owner_address,omitempty" yaml:"owner_address"` +} + +func (m *QueryTokenizeShareRecordRewardRequest) Reset() { *m = QueryTokenizeShareRecordRewardRequest{} } +func (m *QueryTokenizeShareRecordRewardRequest) String() string { return proto.CompactTextString(m) } +func (*QueryTokenizeShareRecordRewardRequest) ProtoMessage() {} +func (*QueryTokenizeShareRecordRewardRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_1a9d927347bb19fc, []int{22} +} +func (m *QueryTokenizeShareRecordRewardRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryTokenizeShareRecordRewardRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryTokenizeShareRecordRewardRequest.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 *QueryTokenizeShareRecordRewardRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryTokenizeShareRecordRewardRequest.Merge(m, src) +} +func (m *QueryTokenizeShareRecordRewardRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryTokenizeShareRecordRewardRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryTokenizeShareRecordRewardRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryTokenizeShareRecordRewardRequest proto.InternalMessageInfo + +// QueryTokenizeShareRecordRewardResponse is the response type for the +// Query/TokenizeShareRecordReward RPC method. +type QueryTokenizeShareRecordRewardResponse struct { + // rewards defines all the rewards accrued by a delegator. + Rewards []TokenizeShareRecordReward `protobuf:"bytes,1,rep,name=rewards,proto3" json:"rewards"` + // total defines the sum of all the rewards. + Total github_com_cosmos_cosmos_sdk_types.DecCoins `protobuf:"bytes,2,rep,name=total,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.DecCoins" json:"total"` +} + +func (m *QueryTokenizeShareRecordRewardResponse) Reset() { + *m = QueryTokenizeShareRecordRewardResponse{} +} +func (m *QueryTokenizeShareRecordRewardResponse) String() string { return proto.CompactTextString(m) } +func (*QueryTokenizeShareRecordRewardResponse) ProtoMessage() {} +func (*QueryTokenizeShareRecordRewardResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_1a9d927347bb19fc, []int{23} +} +func (m *QueryTokenizeShareRecordRewardResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryTokenizeShareRecordRewardResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryTokenizeShareRecordRewardResponse.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 *QueryTokenizeShareRecordRewardResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryTokenizeShareRecordRewardResponse.Merge(m, src) +} +func (m *QueryTokenizeShareRecordRewardResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryTokenizeShareRecordRewardResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryTokenizeShareRecordRewardResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryTokenizeShareRecordRewardResponse proto.InternalMessageInfo + +func (m *QueryTokenizeShareRecordRewardResponse) GetRewards() []TokenizeShareRecordReward { + if m != nil { + return m.Rewards + } + return nil +} + +func (m *QueryTokenizeShareRecordRewardResponse) GetTotal() github_com_cosmos_cosmos_sdk_types.DecCoins { + if m != nil { + return m.Total + } + return nil +} + +func init() { + proto.RegisterType((*QueryLiquidValidatorRequest)(nil), "kyve.liquid.v1beta1.QueryLiquidValidatorRequest") + proto.RegisterType((*QueryLiquidValidatorResponse)(nil), "kyve.liquid.v1beta1.QueryLiquidValidatorResponse") + proto.RegisterType((*QueryLiquidValidatorsRequest)(nil), "kyve.liquid.v1beta1.QueryLiquidValidatorsRequest") + proto.RegisterType((*QueryLiquidValidatorsResponse)(nil), "kyve.liquid.v1beta1.QueryLiquidValidatorsResponse") + proto.RegisterType((*QueryParamsRequest)(nil), "kyve.liquid.v1beta1.QueryParamsRequest") + proto.RegisterType((*QueryParamsResponse)(nil), "kyve.liquid.v1beta1.QueryParamsResponse") + proto.RegisterType((*QueryTokenizeShareRecordByIdRequest)(nil), "kyve.liquid.v1beta1.QueryTokenizeShareRecordByIdRequest") + proto.RegisterType((*QueryTokenizeShareRecordByIdResponse)(nil), "kyve.liquid.v1beta1.QueryTokenizeShareRecordByIdResponse") + proto.RegisterType((*QueryTokenizeShareRecordByDenomRequest)(nil), "kyve.liquid.v1beta1.QueryTokenizeShareRecordByDenomRequest") + proto.RegisterType((*QueryTokenizeShareRecordByDenomResponse)(nil), "kyve.liquid.v1beta1.QueryTokenizeShareRecordByDenomResponse") + proto.RegisterType((*QueryTokenizeShareRecordsOwnedRequest)(nil), "kyve.liquid.v1beta1.QueryTokenizeShareRecordsOwnedRequest") + proto.RegisterType((*QueryTokenizeShareRecordsOwnedResponse)(nil), "kyve.liquid.v1beta1.QueryTokenizeShareRecordsOwnedResponse") + proto.RegisterType((*QueryAllTokenizeShareRecordsRequest)(nil), "kyve.liquid.v1beta1.QueryAllTokenizeShareRecordsRequest") + proto.RegisterType((*QueryAllTokenizeShareRecordsResponse)(nil), "kyve.liquid.v1beta1.QueryAllTokenizeShareRecordsResponse") + proto.RegisterType((*QueryLastTokenizeShareRecordIdRequest)(nil), "kyve.liquid.v1beta1.QueryLastTokenizeShareRecordIdRequest") + proto.RegisterType((*QueryLastTokenizeShareRecordIdResponse)(nil), "kyve.liquid.v1beta1.QueryLastTokenizeShareRecordIdResponse") + proto.RegisterType((*QueryTotalTokenizeSharedAssetsRequest)(nil), "kyve.liquid.v1beta1.QueryTotalTokenizeSharedAssetsRequest") + proto.RegisterType((*QueryTotalTokenizeSharedAssetsResponse)(nil), "kyve.liquid.v1beta1.QueryTotalTokenizeSharedAssetsResponse") + proto.RegisterType((*QueryTotalLiquidStaked)(nil), "kyve.liquid.v1beta1.QueryTotalLiquidStaked") + proto.RegisterType((*QueryTotalLiquidStakedResponse)(nil), "kyve.liquid.v1beta1.QueryTotalLiquidStakedResponse") + proto.RegisterType((*QueryTokenizeShareLockInfo)(nil), "kyve.liquid.v1beta1.QueryTokenizeShareLockInfo") + proto.RegisterType((*QueryTokenizeShareLockInfoResponse)(nil), "kyve.liquid.v1beta1.QueryTokenizeShareLockInfoResponse") + proto.RegisterType((*QueryTokenizeShareRecordRewardRequest)(nil), "kyve.liquid.v1beta1.QueryTokenizeShareRecordRewardRequest") + proto.RegisterType((*QueryTokenizeShareRecordRewardResponse)(nil), "kyve.liquid.v1beta1.QueryTokenizeShareRecordRewardResponse") +} + +func init() { proto.RegisterFile("kyve/liquid/v1beta1/query.proto", fileDescriptor_1a9d927347bb19fc) } + +var fileDescriptor_1a9d927347bb19fc = []byte{ + // 1342 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x58, 0x4f, 0x6f, 0x1b, 0xc5, + 0x1b, 0xf6, 0xe6, 0xd7, 0xa4, 0xbf, 0x0e, 0xf4, 0xdf, 0x34, 0xb4, 0xee, 0xa6, 0xb5, 0xab, 0xa1, + 0xad, 0xad, 0x44, 0xf5, 0x36, 0x31, 0x69, 0xfe, 0x91, 0x40, 0xd2, 0xb4, 0x50, 0x88, 0x4a, 0x71, + 0x4b, 0x25, 0x2a, 0xa4, 0xd5, 0xc4, 0x3b, 0x71, 0x56, 0xb6, 0x77, 0x9c, 0x9d, 0x75, 0x52, 0xd7, + 0xf2, 0x05, 0x09, 0xa9, 0x47, 0x24, 0xbe, 0x40, 0x6f, 0x20, 0x0e, 0x88, 0x13, 0x12, 0x17, 0x0e, + 0x20, 0xa1, 0x5e, 0x10, 0x91, 0x90, 0x10, 0x07, 0x54, 0x4a, 0x82, 0x04, 0x67, 0x3e, 0x01, 0xda, + 0x99, 0xd9, 0x8d, 0xd7, 0xdd, 0x5d, 0xdb, 0x51, 0x2e, 0xb1, 0x77, 0xf6, 0x7d, 0xe6, 0x7d, 0x9e, + 0x99, 0xf7, 0x9d, 0x79, 0x1c, 0x90, 0x2e, 0x37, 0x36, 0x89, 0x56, 0x31, 0x37, 0xea, 0xa6, 0xa1, + 0x6d, 0x8e, 0xaf, 0x12, 0x07, 0x8f, 0x6b, 0x1b, 0x75, 0x62, 0x37, 0x72, 0x35, 0x9b, 0x3a, 0x14, + 0x9e, 0x72, 0x03, 0x72, 0x22, 0x20, 0x27, 0x03, 0xd4, 0xd1, 0x22, 0x65, 0x55, 0xca, 0xb4, 0x55, + 0xcc, 0x88, 0x88, 0xf6, 0xb1, 0x35, 0x5c, 0x32, 0x2d, 0xec, 0x98, 0xd4, 0x12, 0x13, 0xa8, 0xc3, + 0x25, 0x5a, 0xa2, 0xfc, 0xab, 0xe6, 0x7e, 0x93, 0xa3, 0xe7, 0x4a, 0x94, 0x96, 0x2a, 0x44, 0xc3, + 0x35, 0x53, 0xc3, 0x96, 0x45, 0x1d, 0x0e, 0x61, 0xf2, 0xed, 0x85, 0x30, 0x56, 0x92, 0x83, 0x88, + 0x48, 0xb5, 0x33, 0xf0, 0x22, 0x8a, 0xd4, 0xf4, 0xb2, 0x8e, 0xc8, 0xf7, 0x1e, 0xb9, 0x76, 0x4d, + 0xea, 0x49, 0x5c, 0x35, 0x2d, 0xaa, 0xf1, 0xbf, 0x62, 0x08, 0x2d, 0x83, 0x91, 0xf7, 0xdd, 0x88, + 0x15, 0x9e, 0xe4, 0x3e, 0xae, 0x98, 0x06, 0x76, 0xa8, 0x5d, 0x20, 0x1b, 0x75, 0xc2, 0x1c, 0x78, + 0x09, 0x1c, 0xdb, 0xf4, 0xc6, 0x74, 0x6c, 0x18, 0x76, 0x52, 0xb9, 0xa0, 0x64, 0x8f, 0x14, 0x8e, + 0xfa, 0xa3, 0x8b, 0x86, 0x61, 0xa3, 0x47, 0xe0, 0x5c, 0xf8, 0x2c, 0xac, 0x46, 0x2d, 0x46, 0xe0, + 0x03, 0x70, 0x42, 0xa8, 0xd0, 0x7d, 0x1c, 0x9f, 0xe8, 0xa5, 0x89, 0x8b, 0xb9, 0x90, 0x75, 0xce, + 0x75, 0xcc, 0xb3, 0x74, 0xe4, 0xe9, 0xb3, 0x74, 0xe2, 0x8b, 0xbf, 0xbf, 0x1e, 0x55, 0x0a, 0xc7, + 0x2b, 0xc1, 0x77, 0x68, 0x2d, 0x3c, 0x37, 0xf3, 0x24, 0xdc, 0x04, 0x60, 0x6f, 0x6f, 0x64, 0xd6, + 0xcb, 0x39, 0xb1, 0x4c, 0x39, 0x77, 0x19, 0x73, 0x62, 0x89, 0xbc, 0xdc, 0x77, 0x70, 0x89, 0x48, + 0x6c, 0xa1, 0x0d, 0x89, 0x7e, 0x54, 0xc0, 0xf9, 0x88, 0x44, 0x52, 0xe5, 0x47, 0xe0, 0x64, 0xa7, + 0x4a, 0x96, 0x54, 0x2e, 0xfc, 0x6f, 0x3f, 0x32, 0x4f, 0x74, 0xc8, 0x64, 0xf0, 0xad, 0x80, 0x8e, + 0x01, 0xae, 0x23, 0xd3, 0x55, 0x87, 0xa0, 0x16, 0x10, 0x32, 0x0c, 0x20, 0xd7, 0x71, 0x07, 0xdb, + 0xb8, 0xea, 0x2d, 0x13, 0xfa, 0x00, 0x9c, 0x0a, 0x8c, 0x4a, 0x4d, 0x0b, 0x60, 0xa8, 0xc6, 0x47, + 0xe4, 0xca, 0x8d, 0x84, 0x0a, 0x11, 0xa0, 0x76, 0xfe, 0x12, 0x85, 0x26, 0xc1, 0xab, 0x7c, 0xda, + 0x7b, 0xb4, 0x4c, 0x2c, 0xf3, 0x11, 0xb9, 0xbb, 0x8e, 0x6d, 0x52, 0x20, 0x45, 0x6a, 0x1b, 0x4b, + 0x8d, 0x5b, 0x86, 0xb7, 0x49, 0xc7, 0xc0, 0x80, 0x69, 0xf0, 0x14, 0x87, 0x0a, 0x03, 0xa6, 0x81, + 0x2c, 0x70, 0x31, 0x1e, 0x26, 0xe9, 0xdd, 0x04, 0x43, 0x36, 0x1f, 0x95, 0xf4, 0xb2, 0xa1, 0xf4, + 0xc2, 0x66, 0x39, 0xe4, 0x72, 0x2d, 0x48, 0x34, 0x5a, 0x00, 0x97, 0xa3, 0xf3, 0x2d, 0x13, 0x8b, + 0x56, 0x3d, 0xa6, 0xc3, 0x60, 0xd0, 0x70, 0x9f, 0x65, 0x23, 0x88, 0x07, 0xb4, 0x01, 0x32, 0x5d, + 0xf1, 0x07, 0x4c, 0x79, 0x1e, 0x5c, 0x8a, 0x4a, 0xc9, 0xde, 0xdb, 0xb2, 0x88, 0xd1, 0xc6, 0x98, + 0x6e, 0x59, 0xc4, 0x6b, 0x5d, 0xf1, 0x80, 0xec, 0x68, 0xc5, 0x1e, 0x5c, 0x12, 0x7e, 0x1b, 0x1c, + 0x16, 0x29, 0xbd, 0x62, 0xee, 0x97, 0xb1, 0x07, 0x47, 0x55, 0x59, 0x0c, 0x8b, 0x95, 0x4a, 0x58, + 0xda, 0x83, 0xee, 0xd8, 0x6f, 0x15, 0x59, 0x45, 0x91, 0xf9, 0x0e, 0x5a, 0xe1, 0xc1, 0x35, 0x69, + 0x46, 0xee, 0xee, 0x0a, 0x66, 0x4e, 0x48, 0x5e, 0xbf, 0x73, 0xd0, 0xb4, 0xdc, 0xc7, 0x98, 0x40, + 0xa9, 0xb2, 0xb3, 0xc7, 0x32, 0x7e, 0x01, 0x39, 0x38, 0xb8, 0x3e, 0xc6, 0x22, 0x63, 0xc4, 0xf1, + 0x8f, 0x06, 0xdd, 0x2f, 0x95, 0xc8, 0x40, 0x99, 0x62, 0x12, 0x0c, 0x6e, 0xe2, 0x4a, 0x9d, 0xc8, + 0x4d, 0x3b, 0x1b, 0x50, 0xee, 0x69, 0xbe, 0x4e, 0x4d, 0x4b, 0xae, 0x9b, 0x88, 0x46, 0x49, 0x70, + 0x7a, 0x2f, 0x81, 0x38, 0x14, 0xef, 0x3a, 0xb8, 0x4c, 0x0c, 0x34, 0x0d, 0x52, 0xe1, 0x6f, 0xfc, + 0x94, 0xa7, 0xc1, 0x90, 0xe3, 0x52, 0x62, 0xb2, 0xbc, 0xe5, 0x13, 0xba, 0x06, 0xd4, 0x17, 0xeb, + 0x7b, 0x85, 0x16, 0xcb, 0xb7, 0xac, 0x35, 0x0a, 0x93, 0xe0, 0xb0, 0x7b, 0x9b, 0x11, 0xe6, 0xc1, + 0xbc, 0x47, 0x44, 0x00, 0x8a, 0xc6, 0xb5, 0x67, 0x65, 0x0e, 0x76, 0xea, 0x7e, 0x56, 0xf1, 0x04, + 0x33, 0xe0, 0x38, 0x79, 0x58, 0x33, 0x6d, 0xbe, 0x89, 0xba, 0x63, 0x56, 0x09, 0x2f, 0x82, 0x23, + 0x85, 0x63, 0x7b, 0xc3, 0xf7, 0xcc, 0x2a, 0x41, 0xb5, 0xe8, 0xee, 0x2d, 0x90, 0x2d, 0x6c, 0xfb, + 0xdd, 0x3b, 0x0f, 0x8e, 0xf2, 0x86, 0xd5, 0x03, 0x7c, 0x97, 0x92, 0xff, 0x3e, 0x4b, 0x0f, 0x37, + 0x70, 0xb5, 0x32, 0x8b, 0x02, 0xaf, 0x51, 0xe1, 0x65, 0xfe, 0xbc, 0x28, 0x1e, 0x67, 0xff, 0xff, + 0xf8, 0x49, 0x3a, 0xf1, 0xcf, 0x93, 0x74, 0x02, 0xfd, 0xa9, 0x44, 0x77, 0xbc, 0x97, 0x52, 0xaa, + 0xbb, 0xed, 0xf6, 0x83, 0x3b, 0xe2, 0xf5, 0x43, 0xae, 0xd7, 0x7e, 0x10, 0x13, 0xed, 0x75, 0x05, + 0x9f, 0x04, 0x96, 0xc0, 0xa0, 0xe3, 0x6e, 0x60, 0x72, 0x80, 0xcf, 0x76, 0x2e, 0xb4, 0x2c, 0x96, + 0x49, 0x91, 0x57, 0x46, 0xde, 0xc5, 0x7e, 0xf9, 0x47, 0x7a, 0xac, 0x64, 0x3a, 0xeb, 0xf5, 0xd5, + 0x5c, 0x91, 0x56, 0x35, 0x69, 0x6a, 0xc4, 0xc7, 0x15, 0x66, 0x94, 0x35, 0xa7, 0x51, 0x23, 0xcc, + 0xc3, 0xb0, 0x82, 0x98, 0x7f, 0xe2, 0x3b, 0x08, 0x06, 0xb9, 0x46, 0xf8, 0x95, 0x02, 0x4e, 0x74, + 0x5e, 0xd4, 0x70, 0x3c, 0x54, 0x46, 0x9c, 0x7b, 0x50, 0x27, 0xfa, 0x81, 0x88, 0xe5, 0x43, 0xf9, + 0xc7, 0xee, 0x15, 0xf8, 0xf1, 0x2f, 0x7f, 0x7d, 0x36, 0x90, 0x85, 0x97, 0xb5, 0x12, 0x36, 0x71, + 0xb8, 0xa7, 0x6b, 0xf3, 0x09, 0xf0, 0x1b, 0x05, 0x1c, 0xef, 0x98, 0x11, 0x5e, 0xed, 0x39, 0xb9, + 0x47, 0x77, 0xbc, 0x0f, 0x84, 0x64, 0xbb, 0xc0, 0x89, 0x4e, 0xc3, 0x6b, 0x3d, 0x11, 0xd5, 0x9a, + 0x41, 0x3f, 0xd8, 0x82, 0x3f, 0x29, 0xe0, 0x4c, 0xc4, 0x35, 0x0d, 0xa7, 0xa3, 0xe9, 0xc4, 0x1b, + 0x02, 0x75, 0x66, 0x1f, 0x48, 0x29, 0x68, 0x9e, 0x0b, 0x9a, 0x82, 0x93, 0xa1, 0x82, 0x1c, 0x89, + 0xd6, 0x99, 0x0b, 0xd7, 0xc5, 0xc1, 0xad, 0xaf, 0x36, 0x74, 0xd3, 0xd0, 0x9a, 0xa6, 0xd1, 0x82, + 0xbf, 0x2b, 0x40, 0x8d, 0xbe, 0xc6, 0xe1, 0x5c, 0x9f, 0xc4, 0xda, 0xcd, 0x83, 0xfa, 0xfa, 0xfe, + 0xc0, 0x52, 0xd8, 0x75, 0x2e, 0x6c, 0x1e, 0xce, 0xf5, 0x27, 0x8c, 0x3b, 0x14, 0xad, 0xc9, 0x3f, + 0x5a, 0xf0, 0x57, 0x05, 0x9c, 0x8d, 0xbc, 0xf3, 0xe1, 0x6c, 0x5f, 0x04, 0x03, 0x3e, 0x43, 0x9d, + 0xdb, 0x17, 0x56, 0x6a, 0x7b, 0x93, 0x6b, 0x9b, 0x85, 0xd3, 0x7d, 0x68, 0x73, 0x0f, 0x3a, 0x43, + 0x6b, 0xf2, 0xf3, 0xae, 0x05, 0x7f, 0x50, 0xc0, 0x99, 0x88, 0x8b, 0x3e, 0xae, 0x0e, 0xe3, 0xbd, + 0x48, 0x5c, 0x1d, 0x76, 0x71, 0x15, 0x28, 0xcf, 0x25, 0x5d, 0x81, 0x63, 0xbd, 0x4b, 0x62, 0x70, + 0x5b, 0x01, 0x67, 0x23, 0xaf, 0xf2, 0xb8, 0xed, 0xe9, 0x66, 0x14, 0xe2, 0xb6, 0xa7, 0xab, 0x77, + 0x40, 0xb3, 0x5c, 0xcb, 0x6b, 0x70, 0x22, 0xfc, 0x90, 0xc0, 0xcc, 0xd1, 0xc3, 0xf7, 0xc8, 0x34, + 0xe0, 0xcf, 0xbc, 0xe2, 0x22, 0xac, 0x43, 0x7c, 0xc5, 0xc5, 0x1b, 0x93, 0xf8, 0x8a, 0xeb, 0xe2, + 0x55, 0xd0, 0x0c, 0x97, 0x94, 0x87, 0xe3, 0x11, 0xdb, 0xe3, 0xe0, 0x4a, 0x87, 0x26, 0x43, 0xc7, + 0x82, 0xf3, 0xe7, 0x0a, 0x38, 0xf9, 0x82, 0x23, 0x81, 0x63, 0x5d, 0xd8, 0xb4, 0x07, 0xab, 0xf9, + 0x3e, 0x82, 0x7d, 0xca, 0x57, 0x39, 0xe5, 0x51, 0x98, 0x8d, 0xa1, 0x2c, 0x0f, 0x6c, 0x26, 0x38, + 0x7d, 0xaf, 0x80, 0x57, 0xc2, 0x1d, 0x90, 0xd6, 0x63, 0xb7, 0x7a, 0x00, 0x75, 0xaa, 0x4f, 0x80, + 0xcf, 0xfa, 0x0d, 0xce, 0x7a, 0x06, 0x4e, 0xf5, 0xd2, 0x07, 0x15, 0x5a, 0x2c, 0xeb, 0xa6, 0xb5, + 0x46, 0xb5, 0xa6, 0x74, 0x34, 0x2d, 0xf8, 0x89, 0x02, 0x86, 0xc4, 0x2f, 0x4c, 0x98, 0x89, 0x26, + 0x11, 0xf8, 0x39, 0xab, 0x66, 0xbb, 0x07, 0x4a, 0x7a, 0xd9, 0xbd, 0xdb, 0xfa, 0x3c, 0x1c, 0x09, + 0xe5, 0x28, 0x7e, 0xcb, 0xc2, 0xe7, 0xe1, 0x47, 0xa7, 0xf0, 0x3c, 0x7d, 0x1e, 0x9d, 0x01, 0x93, + 0xd7, 0xe7, 0xd1, 0x19, 0x74, 0x6b, 0xe8, 0x1d, 0xce, 0x7d, 0x19, 0x2e, 0x85, 0x72, 0x6f, 0x06, + 0xec, 0x61, 0x2b, 0xe2, 0x28, 0x95, 0x4e, 0x6d, 0xe9, 0xc6, 0xd3, 0x9d, 0x94, 0xb2, 0xbd, 0x93, + 0x52, 0x9e, 0xef, 0xa4, 0x94, 0x4f, 0x77, 0x53, 0x89, 0xed, 0xdd, 0x54, 0xe2, 0xb7, 0xdd, 0x54, + 0xe2, 0x41, 0xbb, 0x1d, 0x7b, 0xf7, 0xc3, 0xfb, 0x37, 0x6e, 0x13, 0x67, 0x8b, 0xda, 0x65, 0xad, + 0xb8, 0x8e, 0x4d, 0x4b, 0x7b, 0xe8, 0xa5, 0xe5, 0xbe, 0x6c, 0x75, 0x88, 0xff, 0x73, 0x29, 0xff, + 0x5f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xf6, 0x76, 0x6c, 0xeb, 0x66, 0x13, 0x00, 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// QueryClient is the client API for Query service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type QueryClient interface { + // LiquidValidators queries all liquid validators. + // + // When called from another module, this query might consume a high amount of + // gas if the pagination field is incorrectly set. + LiquidValidators(ctx context.Context, in *QueryLiquidValidatorsRequest, opts ...grpc.CallOption) (*QueryLiquidValidatorsResponse, error) + // Query for an individual liquid validator by validator address + LiquidValidator(ctx context.Context, in *QueryLiquidValidatorRequest, opts ...grpc.CallOption) (*QueryLiquidValidatorResponse, error) + // Query for individual tokenize share record information by share by id + TokenizeShareRecordById(ctx context.Context, in *QueryTokenizeShareRecordByIdRequest, opts ...grpc.CallOption) (*QueryTokenizeShareRecordByIdResponse, error) + // Query for individual tokenize share record information by share denom + TokenizeShareRecordByDenom(ctx context.Context, in *QueryTokenizeShareRecordByDenomRequest, opts ...grpc.CallOption) (*QueryTokenizeShareRecordByDenomResponse, error) + // Query tokenize share records by address + TokenizeShareRecordsOwned(ctx context.Context, in *QueryTokenizeShareRecordsOwnedRequest, opts ...grpc.CallOption) (*QueryTokenizeShareRecordsOwnedResponse, error) + // Query for all tokenize share records + AllTokenizeShareRecords(ctx context.Context, in *QueryAllTokenizeShareRecordsRequest, opts ...grpc.CallOption) (*QueryAllTokenizeShareRecordsResponse, error) + // Query for last tokenize share record id + LastTokenizeShareRecordId(ctx context.Context, in *QueryLastTokenizeShareRecordIdRequest, opts ...grpc.CallOption) (*QueryLastTokenizeShareRecordIdResponse, error) + // Query for total tokenized staked assets + TotalTokenizeSharedAssets(ctx context.Context, in *QueryTotalTokenizeSharedAssetsRequest, opts ...grpc.CallOption) (*QueryTotalTokenizeSharedAssetsResponse, error) + // Query for total liquid staked (including tokenized shares or owned by an + // liquid staking provider) + TotalLiquidStaked(ctx context.Context, in *QueryTotalLiquidStaked, opts ...grpc.CallOption) (*QueryTotalLiquidStakedResponse, error) + // Query tokenize share locks + TokenizeShareLockInfo(ctx context.Context, in *QueryTokenizeShareLockInfo, opts ...grpc.CallOption) (*QueryTokenizeShareLockInfoResponse, error) + // Parameters queries the liquid parameters. + Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error) + // TokenizeShareRecordReward queries the tokenize share record rewards + TokenizeShareRecordReward(ctx context.Context, in *QueryTokenizeShareRecordRewardRequest, opts ...grpc.CallOption) (*QueryTokenizeShareRecordRewardResponse, error) +} + +type queryClient struct { + cc grpc1.ClientConn +} + +func NewQueryClient(cc grpc1.ClientConn) QueryClient { + return &queryClient{cc} +} + +func (c *queryClient) LiquidValidators(ctx context.Context, in *QueryLiquidValidatorsRequest, opts ...grpc.CallOption) (*QueryLiquidValidatorsResponse, error) { + out := new(QueryLiquidValidatorsResponse) + err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Query/LiquidValidators", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) LiquidValidator(ctx context.Context, in *QueryLiquidValidatorRequest, opts ...grpc.CallOption) (*QueryLiquidValidatorResponse, error) { + out := new(QueryLiquidValidatorResponse) + err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Query/LiquidValidator", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) TokenizeShareRecordById(ctx context.Context, in *QueryTokenizeShareRecordByIdRequest, opts ...grpc.CallOption) (*QueryTokenizeShareRecordByIdResponse, error) { + out := new(QueryTokenizeShareRecordByIdResponse) + err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Query/TokenizeShareRecordById", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) TokenizeShareRecordByDenom(ctx context.Context, in *QueryTokenizeShareRecordByDenomRequest, opts ...grpc.CallOption) (*QueryTokenizeShareRecordByDenomResponse, error) { + out := new(QueryTokenizeShareRecordByDenomResponse) + err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Query/TokenizeShareRecordByDenom", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) TokenizeShareRecordsOwned(ctx context.Context, in *QueryTokenizeShareRecordsOwnedRequest, opts ...grpc.CallOption) (*QueryTokenizeShareRecordsOwnedResponse, error) { + out := new(QueryTokenizeShareRecordsOwnedResponse) + err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Query/TokenizeShareRecordsOwned", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) AllTokenizeShareRecords(ctx context.Context, in *QueryAllTokenizeShareRecordsRequest, opts ...grpc.CallOption) (*QueryAllTokenizeShareRecordsResponse, error) { + out := new(QueryAllTokenizeShareRecordsResponse) + err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Query/AllTokenizeShareRecords", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) LastTokenizeShareRecordId(ctx context.Context, in *QueryLastTokenizeShareRecordIdRequest, opts ...grpc.CallOption) (*QueryLastTokenizeShareRecordIdResponse, error) { + out := new(QueryLastTokenizeShareRecordIdResponse) + err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Query/LastTokenizeShareRecordId", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) TotalTokenizeSharedAssets(ctx context.Context, in *QueryTotalTokenizeSharedAssetsRequest, opts ...grpc.CallOption) (*QueryTotalTokenizeSharedAssetsResponse, error) { + out := new(QueryTotalTokenizeSharedAssetsResponse) + err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Query/TotalTokenizeSharedAssets", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) TotalLiquidStaked(ctx context.Context, in *QueryTotalLiquidStaked, opts ...grpc.CallOption) (*QueryTotalLiquidStakedResponse, error) { + out := new(QueryTotalLiquidStakedResponse) + err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Query/TotalLiquidStaked", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) TokenizeShareLockInfo(ctx context.Context, in *QueryTokenizeShareLockInfo, opts ...grpc.CallOption) (*QueryTokenizeShareLockInfoResponse, error) { + out := new(QueryTokenizeShareLockInfoResponse) + err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Query/TokenizeShareLockInfo", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error) { + out := new(QueryParamsResponse) + err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Query/Params", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) TokenizeShareRecordReward(ctx context.Context, in *QueryTokenizeShareRecordRewardRequest, opts ...grpc.CallOption) (*QueryTokenizeShareRecordRewardResponse, error) { + out := new(QueryTokenizeShareRecordRewardResponse) + err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Query/TokenizeShareRecordReward", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// QueryServer is the server API for Query service. +type QueryServer interface { + // LiquidValidators queries all liquid validators. + // + // When called from another module, this query might consume a high amount of + // gas if the pagination field is incorrectly set. + LiquidValidators(context.Context, *QueryLiquidValidatorsRequest) (*QueryLiquidValidatorsResponse, error) + // Query for an individual liquid validator by validator address + LiquidValidator(context.Context, *QueryLiquidValidatorRequest) (*QueryLiquidValidatorResponse, error) + // Query for individual tokenize share record information by share by id + TokenizeShareRecordById(context.Context, *QueryTokenizeShareRecordByIdRequest) (*QueryTokenizeShareRecordByIdResponse, error) + // Query for individual tokenize share record information by share denom + TokenizeShareRecordByDenom(context.Context, *QueryTokenizeShareRecordByDenomRequest) (*QueryTokenizeShareRecordByDenomResponse, error) + // Query tokenize share records by address + TokenizeShareRecordsOwned(context.Context, *QueryTokenizeShareRecordsOwnedRequest) (*QueryTokenizeShareRecordsOwnedResponse, error) + // Query for all tokenize share records + AllTokenizeShareRecords(context.Context, *QueryAllTokenizeShareRecordsRequest) (*QueryAllTokenizeShareRecordsResponse, error) + // Query for last tokenize share record id + LastTokenizeShareRecordId(context.Context, *QueryLastTokenizeShareRecordIdRequest) (*QueryLastTokenizeShareRecordIdResponse, error) + // Query for total tokenized staked assets + TotalTokenizeSharedAssets(context.Context, *QueryTotalTokenizeSharedAssetsRequest) (*QueryTotalTokenizeSharedAssetsResponse, error) + // Query for total liquid staked (including tokenized shares or owned by an + // liquid staking provider) + TotalLiquidStaked(context.Context, *QueryTotalLiquidStaked) (*QueryTotalLiquidStakedResponse, error) + // Query tokenize share locks + TokenizeShareLockInfo(context.Context, *QueryTokenizeShareLockInfo) (*QueryTokenizeShareLockInfoResponse, error) + // Parameters queries the liquid parameters. + Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error) + // TokenizeShareRecordReward queries the tokenize share record rewards + TokenizeShareRecordReward(context.Context, *QueryTokenizeShareRecordRewardRequest) (*QueryTokenizeShareRecordRewardResponse, error) +} + +// UnimplementedQueryServer can be embedded to have forward compatible implementations. +type UnimplementedQueryServer struct { +} + +func (*UnimplementedQueryServer) LiquidValidators(ctx context.Context, req *QueryLiquidValidatorsRequest) (*QueryLiquidValidatorsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method LiquidValidators not implemented") +} +func (*UnimplementedQueryServer) LiquidValidator(ctx context.Context, req *QueryLiquidValidatorRequest) (*QueryLiquidValidatorResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method LiquidValidator not implemented") +} +func (*UnimplementedQueryServer) TokenizeShareRecordById(ctx context.Context, req *QueryTokenizeShareRecordByIdRequest) (*QueryTokenizeShareRecordByIdResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method TokenizeShareRecordById not implemented") +} +func (*UnimplementedQueryServer) TokenizeShareRecordByDenom(ctx context.Context, req *QueryTokenizeShareRecordByDenomRequest) (*QueryTokenizeShareRecordByDenomResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method TokenizeShareRecordByDenom not implemented") +} +func (*UnimplementedQueryServer) TokenizeShareRecordsOwned(ctx context.Context, req *QueryTokenizeShareRecordsOwnedRequest) (*QueryTokenizeShareRecordsOwnedResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method TokenizeShareRecordsOwned not implemented") +} +func (*UnimplementedQueryServer) AllTokenizeShareRecords(ctx context.Context, req *QueryAllTokenizeShareRecordsRequest) (*QueryAllTokenizeShareRecordsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method AllTokenizeShareRecords not implemented") +} +func (*UnimplementedQueryServer) LastTokenizeShareRecordId(ctx context.Context, req *QueryLastTokenizeShareRecordIdRequest) (*QueryLastTokenizeShareRecordIdResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method LastTokenizeShareRecordId not implemented") +} +func (*UnimplementedQueryServer) TotalTokenizeSharedAssets(ctx context.Context, req *QueryTotalTokenizeSharedAssetsRequest) (*QueryTotalTokenizeSharedAssetsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method TotalTokenizeSharedAssets not implemented") +} +func (*UnimplementedQueryServer) TotalLiquidStaked(ctx context.Context, req *QueryTotalLiquidStaked) (*QueryTotalLiquidStakedResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method TotalLiquidStaked not implemented") +} +func (*UnimplementedQueryServer) TokenizeShareLockInfo(ctx context.Context, req *QueryTokenizeShareLockInfo) (*QueryTokenizeShareLockInfoResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method TokenizeShareLockInfo not implemented") +} +func (*UnimplementedQueryServer) Params(ctx context.Context, req *QueryParamsRequest) (*QueryParamsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Params not implemented") +} +func (*UnimplementedQueryServer) TokenizeShareRecordReward(ctx context.Context, req *QueryTokenizeShareRecordRewardRequest) (*QueryTokenizeShareRecordRewardResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method TokenizeShareRecordReward not implemented") +} + +func RegisterQueryServer(s grpc1.Server, srv QueryServer) { + s.RegisterService(&_Query_serviceDesc, srv) +} + +func _Query_LiquidValidators_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryLiquidValidatorsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).LiquidValidators(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/kyve.liquid.v1beta1.Query/LiquidValidators", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).LiquidValidators(ctx, req.(*QueryLiquidValidatorsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_LiquidValidator_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryLiquidValidatorRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).LiquidValidator(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/kyve.liquid.v1beta1.Query/LiquidValidator", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).LiquidValidator(ctx, req.(*QueryLiquidValidatorRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_TokenizeShareRecordById_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryTokenizeShareRecordByIdRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).TokenizeShareRecordById(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/kyve.liquid.v1beta1.Query/TokenizeShareRecordById", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).TokenizeShareRecordById(ctx, req.(*QueryTokenizeShareRecordByIdRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_TokenizeShareRecordByDenom_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryTokenizeShareRecordByDenomRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).TokenizeShareRecordByDenom(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/kyve.liquid.v1beta1.Query/TokenizeShareRecordByDenom", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).TokenizeShareRecordByDenom(ctx, req.(*QueryTokenizeShareRecordByDenomRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_TokenizeShareRecordsOwned_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryTokenizeShareRecordsOwnedRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).TokenizeShareRecordsOwned(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/kyve.liquid.v1beta1.Query/TokenizeShareRecordsOwned", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).TokenizeShareRecordsOwned(ctx, req.(*QueryTokenizeShareRecordsOwnedRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_AllTokenizeShareRecords_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryAllTokenizeShareRecordsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).AllTokenizeShareRecords(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/kyve.liquid.v1beta1.Query/AllTokenizeShareRecords", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).AllTokenizeShareRecords(ctx, req.(*QueryAllTokenizeShareRecordsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_LastTokenizeShareRecordId_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryLastTokenizeShareRecordIdRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).LastTokenizeShareRecordId(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/kyve.liquid.v1beta1.Query/LastTokenizeShareRecordId", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).LastTokenizeShareRecordId(ctx, req.(*QueryLastTokenizeShareRecordIdRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_TotalTokenizeSharedAssets_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryTotalTokenizeSharedAssetsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).TotalTokenizeSharedAssets(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/kyve.liquid.v1beta1.Query/TotalTokenizeSharedAssets", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).TotalTokenizeSharedAssets(ctx, req.(*QueryTotalTokenizeSharedAssetsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_TotalLiquidStaked_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryTotalLiquidStaked) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).TotalLiquidStaked(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/kyve.liquid.v1beta1.Query/TotalLiquidStaked", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).TotalLiquidStaked(ctx, req.(*QueryTotalLiquidStaked)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_TokenizeShareLockInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryTokenizeShareLockInfo) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).TokenizeShareLockInfo(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/kyve.liquid.v1beta1.Query/TokenizeShareLockInfo", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).TokenizeShareLockInfo(ctx, req.(*QueryTokenizeShareLockInfo)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_Params_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryParamsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).Params(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/kyve.liquid.v1beta1.Query/Params", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).Params(ctx, req.(*QueryParamsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_TokenizeShareRecordReward_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryTokenizeShareRecordRewardRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).TokenizeShareRecordReward(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/kyve.liquid.v1beta1.Query/TokenizeShareRecordReward", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).TokenizeShareRecordReward(ctx, req.(*QueryTokenizeShareRecordRewardRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var Query_serviceDesc = _Query_serviceDesc +var _Query_serviceDesc = grpc.ServiceDesc{ + ServiceName: "kyve.liquid.v1beta1.Query", + HandlerType: (*QueryServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "LiquidValidators", + Handler: _Query_LiquidValidators_Handler, + }, + { + MethodName: "LiquidValidator", + Handler: _Query_LiquidValidator_Handler, + }, + { + MethodName: "TokenizeShareRecordById", + Handler: _Query_TokenizeShareRecordById_Handler, + }, + { + MethodName: "TokenizeShareRecordByDenom", + Handler: _Query_TokenizeShareRecordByDenom_Handler, + }, + { + MethodName: "TokenizeShareRecordsOwned", + Handler: _Query_TokenizeShareRecordsOwned_Handler, + }, + { + MethodName: "AllTokenizeShareRecords", + Handler: _Query_AllTokenizeShareRecords_Handler, + }, + { + MethodName: "LastTokenizeShareRecordId", + Handler: _Query_LastTokenizeShareRecordId_Handler, + }, + { + MethodName: "TotalTokenizeSharedAssets", + Handler: _Query_TotalTokenizeSharedAssets_Handler, + }, + { + MethodName: "TotalLiquidStaked", + Handler: _Query_TotalLiquidStaked_Handler, + }, + { + MethodName: "TokenizeShareLockInfo", + Handler: _Query_TokenizeShareLockInfo_Handler, + }, + { + MethodName: "Params", + Handler: _Query_Params_Handler, + }, + { + MethodName: "TokenizeShareRecordReward", + Handler: _Query_TokenizeShareRecordReward_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "kyve/liquid/v1beta1/query.proto", +} + +func (m *QueryLiquidValidatorRequest) 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 *QueryLiquidValidatorRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryLiquidValidatorRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.ValidatorAddr) > 0 { + i -= len(m.ValidatorAddr) + copy(dAtA[i:], m.ValidatorAddr) + i = encodeVarintQuery(dAtA, i, uint64(len(m.ValidatorAddr))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryLiquidValidatorResponse) 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 *QueryLiquidValidatorResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryLiquidValidatorResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.LiquidValidator.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *QueryLiquidValidatorsRequest) 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 *QueryLiquidValidatorsRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryLiquidValidatorsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Pagination != nil { + { + size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryLiquidValidatorsResponse) 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 *QueryLiquidValidatorsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryLiquidValidatorsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Pagination != nil { + { + size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.LiquidValidators) > 0 { + for iNdEx := len(m.LiquidValidators) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.LiquidValidators[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *QueryParamsRequest) 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 *QueryParamsRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryParamsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *QueryParamsResponse) 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 *QueryParamsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryParamsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Params.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *QueryTokenizeShareRecordByIdRequest) 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 *QueryTokenizeShareRecordByIdRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryTokenizeShareRecordByIdRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Id != 0 { + i = encodeVarintQuery(dAtA, i, uint64(m.Id)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *QueryTokenizeShareRecordByIdResponse) 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 *QueryTokenizeShareRecordByIdResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryTokenizeShareRecordByIdResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Record.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *QueryTokenizeShareRecordByDenomRequest) 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 *QueryTokenizeShareRecordByDenomRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryTokenizeShareRecordByDenomRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Denom) > 0 { + i -= len(m.Denom) + copy(dAtA[i:], m.Denom) + i = encodeVarintQuery(dAtA, i, uint64(len(m.Denom))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryTokenizeShareRecordByDenomResponse) 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 *QueryTokenizeShareRecordByDenomResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryTokenizeShareRecordByDenomResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Record.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *QueryTokenizeShareRecordsOwnedRequest) 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 *QueryTokenizeShareRecordsOwnedRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryTokenizeShareRecordsOwnedRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Owner) > 0 { + i -= len(m.Owner) + copy(dAtA[i:], m.Owner) + i = encodeVarintQuery(dAtA, i, uint64(len(m.Owner))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryTokenizeShareRecordsOwnedResponse) 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 *QueryTokenizeShareRecordsOwnedResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryTokenizeShareRecordsOwnedResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Records) > 0 { + for iNdEx := len(m.Records) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Records[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *QueryAllTokenizeShareRecordsRequest) 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 *QueryAllTokenizeShareRecordsRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryAllTokenizeShareRecordsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Pagination != nil { + { + size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryAllTokenizeShareRecordsResponse) 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 *QueryAllTokenizeShareRecordsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryAllTokenizeShareRecordsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Pagination != nil { + { + size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.Records) > 0 { + for iNdEx := len(m.Records) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Records[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *QueryLastTokenizeShareRecordIdRequest) 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 *QueryLastTokenizeShareRecordIdRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryLastTokenizeShareRecordIdRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *QueryLastTokenizeShareRecordIdResponse) 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 *QueryLastTokenizeShareRecordIdResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryLastTokenizeShareRecordIdResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Id != 0 { + i = encodeVarintQuery(dAtA, i, uint64(m.Id)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *QueryTotalTokenizeSharedAssetsRequest) 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 *QueryTotalTokenizeSharedAssetsRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryTotalTokenizeSharedAssetsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *QueryTotalTokenizeSharedAssetsResponse) 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 *QueryTotalTokenizeSharedAssetsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryTotalTokenizeSharedAssetsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Value.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *QueryTotalLiquidStaked) 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 *QueryTotalLiquidStaked) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryTotalLiquidStaked) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *QueryTotalLiquidStakedResponse) 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 *QueryTotalLiquidStakedResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryTotalLiquidStakedResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Tokens) > 0 { + i -= len(m.Tokens) + copy(dAtA[i:], m.Tokens) + i = encodeVarintQuery(dAtA, i, uint64(len(m.Tokens))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryTokenizeShareLockInfo) 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 *QueryTokenizeShareLockInfo) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryTokenizeShareLockInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Address) > 0 { + i -= len(m.Address) + copy(dAtA[i:], m.Address) + i = encodeVarintQuery(dAtA, i, uint64(len(m.Address))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryTokenizeShareLockInfoResponse) 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 *QueryTokenizeShareLockInfoResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryTokenizeShareLockInfoResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.ExpirationTime) > 0 { + i -= len(m.ExpirationTime) + copy(dAtA[i:], m.ExpirationTime) + i = encodeVarintQuery(dAtA, i, uint64(len(m.ExpirationTime))) + i-- + dAtA[i] = 0x12 + } + if len(m.Status) > 0 { + i -= len(m.Status) + copy(dAtA[i:], m.Status) + i = encodeVarintQuery(dAtA, i, uint64(len(m.Status))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryTokenizeShareRecordRewardRequest) 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 *QueryTokenizeShareRecordRewardRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryTokenizeShareRecordRewardRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.OwnerAddress) > 0 { + i -= len(m.OwnerAddress) + copy(dAtA[i:], m.OwnerAddress) + i = encodeVarintQuery(dAtA, i, uint64(len(m.OwnerAddress))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryTokenizeShareRecordRewardResponse) 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 *QueryTokenizeShareRecordRewardResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryTokenizeShareRecordRewardResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Total) > 0 { + for iNdEx := len(m.Total) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Total[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + if len(m.Rewards) > 0 { + for iNdEx := len(m.Rewards) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Rewards[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func encodeVarintQuery(dAtA []byte, offset int, v uint64) int { + offset -= sovQuery(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *QueryLiquidValidatorRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ValidatorAddr) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryLiquidValidatorResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.LiquidValidator.Size() + n += 1 + l + sovQuery(uint64(l)) + return n +} + +func (m *QueryLiquidValidatorsRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Pagination != nil { + l = m.Pagination.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryLiquidValidatorsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.LiquidValidators) > 0 { + for _, e := range m.LiquidValidators { + l = e.Size() + n += 1 + l + sovQuery(uint64(l)) + } + } + if m.Pagination != nil { + l = m.Pagination.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryParamsRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *QueryParamsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Params.Size() + n += 1 + l + sovQuery(uint64(l)) + return n +} + +func (m *QueryTokenizeShareRecordByIdRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Id != 0 { + n += 1 + sovQuery(uint64(m.Id)) + } + return n +} + +func (m *QueryTokenizeShareRecordByIdResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Record.Size() + n += 1 + l + sovQuery(uint64(l)) + return n +} + +func (m *QueryTokenizeShareRecordByDenomRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Denom) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryTokenizeShareRecordByDenomResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Record.Size() + n += 1 + l + sovQuery(uint64(l)) + return n +} + +func (m *QueryTokenizeShareRecordsOwnedRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Owner) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryTokenizeShareRecordsOwnedResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Records) > 0 { + for _, e := range m.Records { + l = e.Size() + n += 1 + l + sovQuery(uint64(l)) + } + } + return n +} + +func (m *QueryAllTokenizeShareRecordsRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Pagination != nil { + l = m.Pagination.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryAllTokenizeShareRecordsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Records) > 0 { + for _, e := range m.Records { + l = e.Size() + n += 1 + l + sovQuery(uint64(l)) + } + } + if m.Pagination != nil { + l = m.Pagination.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryLastTokenizeShareRecordIdRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *QueryLastTokenizeShareRecordIdResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Id != 0 { + n += 1 + sovQuery(uint64(m.Id)) + } + return n +} + +func (m *QueryTotalTokenizeSharedAssetsRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *QueryTotalTokenizeSharedAssetsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Value.Size() + n += 1 + l + sovQuery(uint64(l)) + return n +} + +func (m *QueryTotalLiquidStaked) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *QueryTotalLiquidStakedResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Tokens) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryTokenizeShareLockInfo) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Address) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryTokenizeShareLockInfoResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Status) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + l = len(m.ExpirationTime) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryTokenizeShareRecordRewardRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.OwnerAddress) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryTokenizeShareRecordRewardResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Rewards) > 0 { + for _, e := range m.Rewards { + l = e.Size() + n += 1 + l + sovQuery(uint64(l)) + } + } + if len(m.Total) > 0 { + for _, e := range m.Total { + l = e.Size() + n += 1 + l + sovQuery(uint64(l)) + } + } + return n +} + +func sovQuery(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozQuery(x uint64) (n int) { + return sovQuery(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *QueryLiquidValidatorRequest) 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 ErrIntOverflowQuery + } + 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: QueryLiquidValidatorRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryLiquidValidatorRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddr", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + 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 ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ValidatorAddr = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryLiquidValidatorResponse) 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 ErrIntOverflowQuery + } + 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: QueryLiquidValidatorResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryLiquidValidatorResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LiquidValidator", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.LiquidValidator.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryLiquidValidatorsRequest) 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 ErrIntOverflowQuery + } + 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: QueryLiquidValidatorsRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryLiquidValidatorsRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Pagination == nil { + m.Pagination = &query.PageRequest{} + } + if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryLiquidValidatorsResponse) 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 ErrIntOverflowQuery + } + 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: QueryLiquidValidatorsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryLiquidValidatorsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LiquidValidators", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.LiquidValidators = append(m.LiquidValidators, LiquidValidator{}) + if err := m.LiquidValidators[len(m.LiquidValidators)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Pagination == nil { + m.Pagination = &query.PageResponse{} + } + if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryParamsRequest) 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 ErrIntOverflowQuery + } + 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: QueryParamsRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryParamsRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryParamsResponse) 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 ErrIntOverflowQuery + } + 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: QueryParamsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryParamsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryTokenizeShareRecordByIdRequest) 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 ErrIntOverflowQuery + } + 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: QueryTokenizeShareRecordByIdRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryTokenizeShareRecordByIdRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + m.Id = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Id |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryTokenizeShareRecordByIdResponse) 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 ErrIntOverflowQuery + } + 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: QueryTokenizeShareRecordByIdResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryTokenizeShareRecordByIdResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Record", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Record.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryTokenizeShareRecordByDenomRequest) 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 ErrIntOverflowQuery + } + 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: QueryTokenizeShareRecordByDenomRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryTokenizeShareRecordByDenomRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + 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 ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Denom = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryTokenizeShareRecordByDenomResponse) 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 ErrIntOverflowQuery + } + 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: QueryTokenizeShareRecordByDenomResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryTokenizeShareRecordByDenomResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Record", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Record.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryTokenizeShareRecordsOwnedRequest) 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 ErrIntOverflowQuery + } + 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: QueryTokenizeShareRecordsOwnedRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryTokenizeShareRecordsOwnedRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Owner", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + 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 ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Owner = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryTokenizeShareRecordsOwnedResponse) 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 ErrIntOverflowQuery + } + 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: QueryTokenizeShareRecordsOwnedResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryTokenizeShareRecordsOwnedResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Records", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Records = append(m.Records, TokenizeShareRecord{}) + if err := m.Records[len(m.Records)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryAllTokenizeShareRecordsRequest) 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 ErrIntOverflowQuery + } + 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: QueryAllTokenizeShareRecordsRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryAllTokenizeShareRecordsRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Pagination == nil { + m.Pagination = &query.PageRequest{} + } + if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryAllTokenizeShareRecordsResponse) 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 ErrIntOverflowQuery + } + 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: QueryAllTokenizeShareRecordsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryAllTokenizeShareRecordsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Records", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Records = append(m.Records, TokenizeShareRecord{}) + if err := m.Records[len(m.Records)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Pagination == nil { + m.Pagination = &query.PageResponse{} + } + if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryLastTokenizeShareRecordIdRequest) 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 ErrIntOverflowQuery + } + 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: QueryLastTokenizeShareRecordIdRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryLastTokenizeShareRecordIdRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryLastTokenizeShareRecordIdResponse) 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 ErrIntOverflowQuery + } + 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: QueryLastTokenizeShareRecordIdResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryLastTokenizeShareRecordIdResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + m.Id = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Id |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryTotalTokenizeSharedAssetsRequest) 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 ErrIntOverflowQuery + } + 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: QueryTotalTokenizeSharedAssetsRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryTotalTokenizeSharedAssetsRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryTotalTokenizeSharedAssetsResponse) 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 ErrIntOverflowQuery + } + 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: QueryTotalTokenizeSharedAssetsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryTotalTokenizeSharedAssetsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryTotalLiquidStaked) 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 ErrIntOverflowQuery + } + 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: QueryTotalLiquidStaked: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryTotalLiquidStaked: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryTotalLiquidStakedResponse) 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 ErrIntOverflowQuery + } + 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: QueryTotalLiquidStakedResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryTotalLiquidStakedResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Tokens", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + 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 ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Tokens = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryTokenizeShareLockInfo) 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 ErrIntOverflowQuery + } + 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: QueryTokenizeShareLockInfo: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryTokenizeShareLockInfo: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + 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 ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Address = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryTokenizeShareLockInfoResponse) 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 ErrIntOverflowQuery + } + 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: QueryTokenizeShareLockInfoResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryTokenizeShareLockInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + 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 ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Status = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExpirationTime", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + 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 ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ExpirationTime = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryTokenizeShareRecordRewardRequest) 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 ErrIntOverflowQuery + } + 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: QueryTokenizeShareRecordRewardRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryTokenizeShareRecordRewardRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OwnerAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + 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 ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.OwnerAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryTokenizeShareRecordRewardResponse) 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 ErrIntOverflowQuery + } + 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: QueryTokenizeShareRecordRewardResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryTokenizeShareRecordRewardResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Rewards", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Rewards = append(m.Rewards, TokenizeShareRecordReward{}) + if err := m.Rewards[len(m.Rewards)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Total", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Total = append(m.Total, types.DecCoin{}) + if err := m.Total[len(m.Total)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipQuery(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowQuery + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowQuery + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowQuery + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthQuery + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupQuery + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthQuery + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthQuery = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowQuery = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupQuery = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/liquid/types/query.pb.gw.go b/x/liquid/types/query.pb.gw.go new file mode 100644 index 00000000..41b6ec20 --- /dev/null +++ b/x/liquid/types/query.pb.gw.go @@ -0,0 +1,1120 @@ +// Code generated by protoc-gen-grpc-gateway. DO NOT EDIT. +// source: kyve/liquid/v1beta1/query.proto + +/* +Package types is a reverse proxy. + +It translates gRPC into RESTful JSON APIs. +*/ +package types + +import ( + "context" + "io" + "net/http" + + "github.com/golang/protobuf/descriptor" + "github.com/golang/protobuf/proto" + "github.com/grpc-ecosystem/grpc-gateway/runtime" + "github.com/grpc-ecosystem/grpc-gateway/utilities" + "google.golang.org/grpc" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/grpclog" + "google.golang.org/grpc/metadata" + "google.golang.org/grpc/status" +) + +// Suppress "imported and not used" errors +var _ codes.Code +var _ io.Reader +var _ status.Status +var _ = runtime.String +var _ = utilities.NewDoubleArray +var _ = descriptor.ForMessage +var _ = metadata.Join + +var ( + filter_Query_LiquidValidators_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} +) + +func request_Query_LiquidValidators_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryLiquidValidatorsRequest + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_LiquidValidators_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.LiquidValidators(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_LiquidValidators_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryLiquidValidatorsRequest + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_LiquidValidators_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.LiquidValidators(ctx, &protoReq) + return msg, metadata, err + +} + +func request_Query_LiquidValidator_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryLiquidValidatorRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["validator_addr"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "validator_addr") + } + + protoReq.ValidatorAddr, err = runtime.String(val) + + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "validator_addr", err) + } + + msg, err := client.LiquidValidator(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_LiquidValidator_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryLiquidValidatorRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["validator_addr"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "validator_addr") + } + + protoReq.ValidatorAddr, err = runtime.String(val) + + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "validator_addr", err) + } + + msg, err := server.LiquidValidator(ctx, &protoReq) + return msg, metadata, err + +} + +func request_Query_TokenizeShareRecordById_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryTokenizeShareRecordByIdRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["id"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id") + } + + protoReq.Id, err = runtime.Uint64(val) + + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err) + } + + msg, err := client.TokenizeShareRecordById(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_TokenizeShareRecordById_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryTokenizeShareRecordByIdRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["id"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id") + } + + protoReq.Id, err = runtime.Uint64(val) + + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err) + } + + msg, err := server.TokenizeShareRecordById(ctx, &protoReq) + return msg, metadata, err + +} + +func request_Query_TokenizeShareRecordByDenom_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryTokenizeShareRecordByDenomRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["denom"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "denom") + } + + protoReq.Denom, err = runtime.String(val) + + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "denom", err) + } + + msg, err := client.TokenizeShareRecordByDenom(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_TokenizeShareRecordByDenom_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryTokenizeShareRecordByDenomRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["denom"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "denom") + } + + protoReq.Denom, err = runtime.String(val) + + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "denom", err) + } + + msg, err := server.TokenizeShareRecordByDenom(ctx, &protoReq) + return msg, metadata, err + +} + +func request_Query_TokenizeShareRecordsOwned_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryTokenizeShareRecordsOwnedRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["owner"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "owner") + } + + protoReq.Owner, err = runtime.String(val) + + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "owner", err) + } + + msg, err := client.TokenizeShareRecordsOwned(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_TokenizeShareRecordsOwned_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryTokenizeShareRecordsOwnedRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["owner"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "owner") + } + + protoReq.Owner, err = runtime.String(val) + + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "owner", err) + } + + msg, err := server.TokenizeShareRecordsOwned(ctx, &protoReq) + return msg, metadata, err + +} + +var ( + filter_Query_AllTokenizeShareRecords_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} +) + +func request_Query_AllTokenizeShareRecords_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryAllTokenizeShareRecordsRequest + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_AllTokenizeShareRecords_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.AllTokenizeShareRecords(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_AllTokenizeShareRecords_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryAllTokenizeShareRecordsRequest + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_AllTokenizeShareRecords_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.AllTokenizeShareRecords(ctx, &protoReq) + return msg, metadata, err + +} + +func request_Query_LastTokenizeShareRecordId_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryLastTokenizeShareRecordIdRequest + var metadata runtime.ServerMetadata + + msg, err := client.LastTokenizeShareRecordId(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_LastTokenizeShareRecordId_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryLastTokenizeShareRecordIdRequest + var metadata runtime.ServerMetadata + + msg, err := server.LastTokenizeShareRecordId(ctx, &protoReq) + return msg, metadata, err + +} + +func request_Query_TotalTokenizeSharedAssets_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryTotalTokenizeSharedAssetsRequest + var metadata runtime.ServerMetadata + + msg, err := client.TotalTokenizeSharedAssets(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_TotalTokenizeSharedAssets_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryTotalTokenizeSharedAssetsRequest + var metadata runtime.ServerMetadata + + msg, err := server.TotalTokenizeSharedAssets(ctx, &protoReq) + return msg, metadata, err + +} + +func request_Query_TotalLiquidStaked_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryTotalLiquidStaked + var metadata runtime.ServerMetadata + + msg, err := client.TotalLiquidStaked(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_TotalLiquidStaked_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryTotalLiquidStaked + var metadata runtime.ServerMetadata + + msg, err := server.TotalLiquidStaked(ctx, &protoReq) + return msg, metadata, err + +} + +func request_Query_TokenizeShareLockInfo_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryTokenizeShareLockInfo + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["address"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "address") + } + + protoReq.Address, err = runtime.String(val) + + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "address", err) + } + + msg, err := client.TokenizeShareLockInfo(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_TokenizeShareLockInfo_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryTokenizeShareLockInfo + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["address"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "address") + } + + protoReq.Address, err = runtime.String(val) + + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "address", err) + } + + msg, err := server.TokenizeShareLockInfo(ctx, &protoReq) + return msg, metadata, err + +} + +func request_Query_Params_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryParamsRequest + var metadata runtime.ServerMetadata + + msg, err := client.Params(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_Params_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryParamsRequest + var metadata runtime.ServerMetadata + + msg, err := server.Params(ctx, &protoReq) + return msg, metadata, err + +} + +func request_Query_TokenizeShareRecordReward_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryTokenizeShareRecordRewardRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["owner_address"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "owner_address") + } + + protoReq.OwnerAddress, err = runtime.String(val) + + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "owner_address", err) + } + + msg, err := client.TokenizeShareRecordReward(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_TokenizeShareRecordReward_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryTokenizeShareRecordRewardRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["owner_address"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "owner_address") + } + + protoReq.OwnerAddress, err = runtime.String(val) + + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "owner_address", err) + } + + msg, err := server.TokenizeShareRecordReward(ctx, &protoReq) + return msg, metadata, err + +} + +// RegisterQueryHandlerServer registers the http handlers for service Query to "mux". +// UnaryRPC :call QueryServer directly. +// StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. +// Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterQueryHandlerFromEndpoint instead. +func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, server QueryServer) error { + + mux.Handle("GET", pattern_Query_LiquidValidators_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_Query_LiquidValidators_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_Query_LiquidValidators_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_LiquidValidator_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_Query_LiquidValidator_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_Query_LiquidValidator_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_TokenizeShareRecordById_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_Query_TokenizeShareRecordById_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_Query_TokenizeShareRecordById_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_TokenizeShareRecordByDenom_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_Query_TokenizeShareRecordByDenom_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_Query_TokenizeShareRecordByDenom_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_TokenizeShareRecordsOwned_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_Query_TokenizeShareRecordsOwned_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_Query_TokenizeShareRecordsOwned_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_AllTokenizeShareRecords_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_Query_AllTokenizeShareRecords_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_Query_AllTokenizeShareRecords_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_LastTokenizeShareRecordId_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_Query_LastTokenizeShareRecordId_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_Query_LastTokenizeShareRecordId_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_TotalTokenizeSharedAssets_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_Query_TotalTokenizeSharedAssets_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_Query_TotalTokenizeSharedAssets_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_TotalLiquidStaked_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_Query_TotalLiquidStaked_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_Query_TotalLiquidStaked_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_TokenizeShareLockInfo_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_Query_TokenizeShareLockInfo_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_Query_TokenizeShareLockInfo_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_Params_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_Query_Params_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_Query_Params_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_TokenizeShareRecordReward_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_Query_TokenizeShareRecordReward_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_Query_TokenizeShareRecordReward_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + return nil +} + +// RegisterQueryHandlerFromEndpoint is same as RegisterQueryHandler but +// automatically dials to "endpoint" and closes the connection when "ctx" gets done. +func RegisterQueryHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { + conn, err := grpc.Dial(endpoint, opts...) + if err != nil { + return err + } + defer func() { + if err != nil { + if cerr := conn.Close(); cerr != nil { + grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) + } + return + } + go func() { + <-ctx.Done() + if cerr := conn.Close(); cerr != nil { + grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) + } + }() + }() + + return RegisterQueryHandler(ctx, mux, conn) +} + +// RegisterQueryHandler registers the http handlers for service Query to "mux". +// The handlers forward requests to the grpc endpoint over "conn". +func RegisterQueryHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { + return RegisterQueryHandlerClient(ctx, mux, NewQueryClient(conn)) +} + +// RegisterQueryHandlerClient registers the http handlers for service Query +// to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "QueryClient". +// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "QueryClient" +// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in +// "QueryClient" to call the correct interceptors. +func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, client QueryClient) error { + + mux.Handle("GET", pattern_Query_LiquidValidators_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_Query_LiquidValidators_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_LiquidValidators_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_LiquidValidator_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_Query_LiquidValidator_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_LiquidValidator_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_TokenizeShareRecordById_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_Query_TokenizeShareRecordById_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_TokenizeShareRecordById_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_TokenizeShareRecordByDenom_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_Query_TokenizeShareRecordByDenom_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_TokenizeShareRecordByDenom_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_TokenizeShareRecordsOwned_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_Query_TokenizeShareRecordsOwned_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_TokenizeShareRecordsOwned_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_AllTokenizeShareRecords_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_Query_AllTokenizeShareRecords_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_AllTokenizeShareRecords_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_LastTokenizeShareRecordId_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_Query_LastTokenizeShareRecordId_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_LastTokenizeShareRecordId_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_TotalTokenizeSharedAssets_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_Query_TotalTokenizeSharedAssets_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_TotalTokenizeSharedAssets_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_TotalLiquidStaked_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_Query_TotalLiquidStaked_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_TotalLiquidStaked_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_TokenizeShareLockInfo_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_Query_TokenizeShareLockInfo_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_TokenizeShareLockInfo_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_Params_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_Query_Params_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_Params_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_TokenizeShareRecordReward_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_Query_TokenizeShareRecordReward_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_TokenizeShareRecordReward_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + return nil +} + +var ( + pattern_Query_LiquidValidators_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gaia", "liquid", "v1beta1", "liquid_validators"}, "", runtime.AssumeColonVerbOpt(true))) + + pattern_Query_LiquidValidator_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"gaia", "liquid", "v1beta1", "liquid_validator", "validator_addr"}, "", runtime.AssumeColonVerbOpt(true))) + + pattern_Query_TokenizeShareRecordById_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"gaia", "liquid", "v1beta1", "tokenize_share_record_by_id", "id"}, "", runtime.AssumeColonVerbOpt(true))) + + pattern_Query_TokenizeShareRecordByDenom_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"gaia", "liquid", "v1beta1", "tokenize_share_record_by_denom", "denom"}, "", runtime.AssumeColonVerbOpt(true))) + + pattern_Query_TokenizeShareRecordsOwned_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"gaia", "liquid", "v1beta1", "tokenize_share_record_owned", "owner"}, "", runtime.AssumeColonVerbOpt(true))) + + pattern_Query_AllTokenizeShareRecords_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gaia", "liquid", "v1beta1", "tokenize_share_records"}, "", runtime.AssumeColonVerbOpt(true))) + + pattern_Query_LastTokenizeShareRecordId_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gaia", "liquid", "v1beta1", "last_tokenize_share_record_id"}, "", runtime.AssumeColonVerbOpt(true))) + + pattern_Query_TotalTokenizeSharedAssets_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gaia", "liquid", "v1beta1", "total_tokenize_shared_assets"}, "", runtime.AssumeColonVerbOpt(true))) + + pattern_Query_TotalLiquidStaked_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gaia", "liquid", "v1beta1", "total_liquid_staked"}, "", runtime.AssumeColonVerbOpt(true))) + + pattern_Query_TokenizeShareLockInfo_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"gaia", "liquid", "v1beta1", "tokenize_share_lock_info", "address"}, "", runtime.AssumeColonVerbOpt(true))) + + pattern_Query_Params_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gaia", "liquid", "v1beta1", "params"}, "", runtime.AssumeColonVerbOpt(true))) + + pattern_Query_TokenizeShareRecordReward_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 2, 4}, []string{"gaia", "liquid", "v1beta1", "owner_address", "tokenize_share_record_rewards"}, "", runtime.AssumeColonVerbOpt(true))) +) + +var ( + forward_Query_LiquidValidators_0 = runtime.ForwardResponseMessage + + forward_Query_LiquidValidator_0 = runtime.ForwardResponseMessage + + forward_Query_TokenizeShareRecordById_0 = runtime.ForwardResponseMessage + + forward_Query_TokenizeShareRecordByDenom_0 = runtime.ForwardResponseMessage + + forward_Query_TokenizeShareRecordsOwned_0 = runtime.ForwardResponseMessage + + forward_Query_AllTokenizeShareRecords_0 = runtime.ForwardResponseMessage + + forward_Query_LastTokenizeShareRecordId_0 = runtime.ForwardResponseMessage + + forward_Query_TotalTokenizeSharedAssets_0 = runtime.ForwardResponseMessage + + forward_Query_TotalLiquidStaked_0 = runtime.ForwardResponseMessage + + forward_Query_TokenizeShareLockInfo_0 = runtime.ForwardResponseMessage + + forward_Query_Params_0 = runtime.ForwardResponseMessage + + forward_Query_TokenizeShareRecordReward_0 = runtime.ForwardResponseMessage +) diff --git a/x/liquid/types/tokenize_share_record.go b/x/liquid/types/tokenize_share_record.go new file mode 100644 index 00000000..7b09c89e --- /dev/null +++ b/x/liquid/types/tokenize_share_record.go @@ -0,0 +1,22 @@ +package types + +import ( + "fmt" + "strconv" + "strings" + + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/types/address" +) + +func (r TokenizeShareRecord) GetModuleAddress() sdk.AccAddress { + // NOTE: The module name is intentionally hard coded so that, if this + // function were to move to a different module in future SDK version, + // it would not break all the address lookups + moduleName := "lsm" + return address.Module(moduleName, []byte(r.ModuleAccount)) +} + +func (r TokenizeShareRecord) GetShareTokenDenom() string { + return fmt.Sprintf("%s/%s", strings.ToLower(r.Validator), strconv.FormatUint(r.Id, 10)) +} diff --git a/x/liquid/types/tx.pb.go b/x/liquid/types/tx.pb.go new file mode 100644 index 00000000..65f23e58 --- /dev/null +++ b/x/liquid/types/tx.pb.go @@ -0,0 +1,3374 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: kyve/liquid/v1beta1/tx.proto + +package types + +import ( + context "context" + fmt "fmt" + _ "github.com/cosmos/cosmos-proto" + types "github.com/cosmos/cosmos-sdk/types" + _ "github.com/cosmos/cosmos-sdk/types/msgservice" + _ "github.com/cosmos/cosmos-sdk/types/tx/amino" + _ "github.com/cosmos/gogoproto/gogoproto" + grpc1 "github.com/cosmos/gogoproto/grpc" + proto "github.com/cosmos/gogoproto/proto" + github_com_cosmos_gogoproto_types "github.com/cosmos/gogoproto/types" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + _ "google.golang.org/protobuf/types/known/timestamppb" + io "io" + math "math" + math_bits "math/bits" + time "time" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf +var _ = time.Kitchen + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +// MsgUpdateParams is the Msg/UpdateParams request type. +type MsgUpdateParams struct { + // authority is the address that controls the module (defaults to x/gov unless + // overwritten). + Authority string `protobuf:"bytes,1,opt,name=authority,proto3" json:"authority,omitempty"` + // params defines the x/liquid parameters to update. + // + // NOTE: All parameters must be supplied. + Params Params `protobuf:"bytes,2,opt,name=params,proto3" json:"params"` +} + +func (m *MsgUpdateParams) Reset() { *m = MsgUpdateParams{} } +func (m *MsgUpdateParams) String() string { return proto.CompactTextString(m) } +func (*MsgUpdateParams) ProtoMessage() {} +func (*MsgUpdateParams) Descriptor() ([]byte, []int) { + return fileDescriptor_a63931950704005e, []int{0} +} +func (m *MsgUpdateParams) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgUpdateParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgUpdateParams.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 *MsgUpdateParams) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgUpdateParams.Merge(m, src) +} +func (m *MsgUpdateParams) XXX_Size() int { + return m.Size() +} +func (m *MsgUpdateParams) XXX_DiscardUnknown() { + xxx_messageInfo_MsgUpdateParams.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgUpdateParams proto.InternalMessageInfo + +func (m *MsgUpdateParams) GetAuthority() string { + if m != nil { + return m.Authority + } + return "" +} + +func (m *MsgUpdateParams) GetParams() Params { + if m != nil { + return m.Params + } + return Params{} +} + +// MsgUpdateParamsResponse defines the response structure for executing a +// MsgUpdateParams message. +type MsgUpdateParamsResponse struct { +} + +func (m *MsgUpdateParamsResponse) Reset() { *m = MsgUpdateParamsResponse{} } +func (m *MsgUpdateParamsResponse) String() string { return proto.CompactTextString(m) } +func (*MsgUpdateParamsResponse) ProtoMessage() {} +func (*MsgUpdateParamsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_a63931950704005e, []int{1} +} +func (m *MsgUpdateParamsResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgUpdateParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgUpdateParamsResponse.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 *MsgUpdateParamsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgUpdateParamsResponse.Merge(m, src) +} +func (m *MsgUpdateParamsResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgUpdateParamsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgUpdateParamsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgUpdateParamsResponse proto.InternalMessageInfo + +// MsgTokenizeShares tokenizes a delegation +type MsgTokenizeShares struct { + DelegatorAddress string `protobuf:"bytes,1,opt,name=delegator_address,json=delegatorAddress,proto3" json:"delegator_address,omitempty" yaml:"delegator_address"` + ValidatorAddress string `protobuf:"bytes,2,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty" yaml:"validator_address"` + Amount types.Coin `protobuf:"bytes,3,opt,name=amount,proto3" json:"amount"` + TokenizedShareOwner string `protobuf:"bytes,4,opt,name=tokenized_share_owner,json=tokenizedShareOwner,proto3" json:"tokenized_share_owner,omitempty"` +} + +func (m *MsgTokenizeShares) Reset() { *m = MsgTokenizeShares{} } +func (m *MsgTokenizeShares) String() string { return proto.CompactTextString(m) } +func (*MsgTokenizeShares) ProtoMessage() {} +func (*MsgTokenizeShares) Descriptor() ([]byte, []int) { + return fileDescriptor_a63931950704005e, []int{2} +} +func (m *MsgTokenizeShares) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgTokenizeShares) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgTokenizeShares.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 *MsgTokenizeShares) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgTokenizeShares.Merge(m, src) +} +func (m *MsgTokenizeShares) XXX_Size() int { + return m.Size() +} +func (m *MsgTokenizeShares) XXX_DiscardUnknown() { + xxx_messageInfo_MsgTokenizeShares.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgTokenizeShares proto.InternalMessageInfo + +// MsgTokenizeSharesResponse defines the Msg/MsgTokenizeShares response type. +type MsgTokenizeSharesResponse struct { + Amount types.Coin `protobuf:"bytes,1,opt,name=amount,proto3" json:"amount"` +} + +func (m *MsgTokenizeSharesResponse) Reset() { *m = MsgTokenizeSharesResponse{} } +func (m *MsgTokenizeSharesResponse) String() string { return proto.CompactTextString(m) } +func (*MsgTokenizeSharesResponse) ProtoMessage() {} +func (*MsgTokenizeSharesResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_a63931950704005e, []int{3} +} +func (m *MsgTokenizeSharesResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgTokenizeSharesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgTokenizeSharesResponse.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 *MsgTokenizeSharesResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgTokenizeSharesResponse.Merge(m, src) +} +func (m *MsgTokenizeSharesResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgTokenizeSharesResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgTokenizeSharesResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgTokenizeSharesResponse proto.InternalMessageInfo + +func (m *MsgTokenizeSharesResponse) GetAmount() types.Coin { + if m != nil { + return m.Amount + } + return types.Coin{} +} + +// MsgRedeemTokensForShares redeems a tokenized share back into a native +// delegation +type MsgRedeemTokensForShares struct { + DelegatorAddress string `protobuf:"bytes,1,opt,name=delegator_address,json=delegatorAddress,proto3" json:"delegator_address,omitempty" yaml:"delegator_address"` + Amount types.Coin `protobuf:"bytes,2,opt,name=amount,proto3" json:"amount"` +} + +func (m *MsgRedeemTokensForShares) Reset() { *m = MsgRedeemTokensForShares{} } +func (m *MsgRedeemTokensForShares) String() string { return proto.CompactTextString(m) } +func (*MsgRedeemTokensForShares) ProtoMessage() {} +func (*MsgRedeemTokensForShares) Descriptor() ([]byte, []int) { + return fileDescriptor_a63931950704005e, []int{4} +} +func (m *MsgRedeemTokensForShares) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgRedeemTokensForShares) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgRedeemTokensForShares.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 *MsgRedeemTokensForShares) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgRedeemTokensForShares.Merge(m, src) +} +func (m *MsgRedeemTokensForShares) XXX_Size() int { + return m.Size() +} +func (m *MsgRedeemTokensForShares) XXX_DiscardUnknown() { + xxx_messageInfo_MsgRedeemTokensForShares.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgRedeemTokensForShares proto.InternalMessageInfo + +// MsgRedeemTokensForSharesResponse defines the Msg/MsgRedeemTokensForShares +// response type. +type MsgRedeemTokensForSharesResponse struct { + Amount types.Coin `protobuf:"bytes,1,opt,name=amount,proto3" json:"amount"` +} + +func (m *MsgRedeemTokensForSharesResponse) Reset() { *m = MsgRedeemTokensForSharesResponse{} } +func (m *MsgRedeemTokensForSharesResponse) String() string { return proto.CompactTextString(m) } +func (*MsgRedeemTokensForSharesResponse) ProtoMessage() {} +func (*MsgRedeemTokensForSharesResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_a63931950704005e, []int{5} +} +func (m *MsgRedeemTokensForSharesResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgRedeemTokensForSharesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgRedeemTokensForSharesResponse.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 *MsgRedeemTokensForSharesResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgRedeemTokensForSharesResponse.Merge(m, src) +} +func (m *MsgRedeemTokensForSharesResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgRedeemTokensForSharesResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgRedeemTokensForSharesResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgRedeemTokensForSharesResponse proto.InternalMessageInfo + +func (m *MsgRedeemTokensForSharesResponse) GetAmount() types.Coin { + if m != nil { + return m.Amount + } + return types.Coin{} +} + +// MsgTransferTokenizeShareRecord transfer a tokenize share record +type MsgTransferTokenizeShareRecord struct { + TokenizeShareRecordId uint64 `protobuf:"varint,1,opt,name=tokenize_share_record_id,json=tokenizeShareRecordId,proto3" json:"tokenize_share_record_id,omitempty"` + Sender string `protobuf:"bytes,2,opt,name=sender,proto3" json:"sender,omitempty"` + NewOwner string `protobuf:"bytes,3,opt,name=new_owner,json=newOwner,proto3" json:"new_owner,omitempty"` +} + +func (m *MsgTransferTokenizeShareRecord) Reset() { *m = MsgTransferTokenizeShareRecord{} } +func (m *MsgTransferTokenizeShareRecord) String() string { return proto.CompactTextString(m) } +func (*MsgTransferTokenizeShareRecord) ProtoMessage() {} +func (*MsgTransferTokenizeShareRecord) Descriptor() ([]byte, []int) { + return fileDescriptor_a63931950704005e, []int{6} +} +func (m *MsgTransferTokenizeShareRecord) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgTransferTokenizeShareRecord) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgTransferTokenizeShareRecord.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 *MsgTransferTokenizeShareRecord) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgTransferTokenizeShareRecord.Merge(m, src) +} +func (m *MsgTransferTokenizeShareRecord) XXX_Size() int { + return m.Size() +} +func (m *MsgTransferTokenizeShareRecord) XXX_DiscardUnknown() { + xxx_messageInfo_MsgTransferTokenizeShareRecord.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgTransferTokenizeShareRecord proto.InternalMessageInfo + +// MsgTransferTokenizeShareRecordResponse defines the +// Msg/MsgTransferTokenizeShareRecord response type. +type MsgTransferTokenizeShareRecordResponse struct { +} + +func (m *MsgTransferTokenizeShareRecordResponse) Reset() { + *m = MsgTransferTokenizeShareRecordResponse{} +} +func (m *MsgTransferTokenizeShareRecordResponse) String() string { return proto.CompactTextString(m) } +func (*MsgTransferTokenizeShareRecordResponse) ProtoMessage() {} +func (*MsgTransferTokenizeShareRecordResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_a63931950704005e, []int{7} +} +func (m *MsgTransferTokenizeShareRecordResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgTransferTokenizeShareRecordResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgTransferTokenizeShareRecordResponse.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 *MsgTransferTokenizeShareRecordResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgTransferTokenizeShareRecordResponse.Merge(m, src) +} +func (m *MsgTransferTokenizeShareRecordResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgTransferTokenizeShareRecordResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgTransferTokenizeShareRecordResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgTransferTokenizeShareRecordResponse proto.InternalMessageInfo + +// MsgDisableTokenizeShares prevents the tokenization of shares for a given +// address +type MsgDisableTokenizeShares struct { + DelegatorAddress string `protobuf:"bytes,1,opt,name=delegator_address,json=delegatorAddress,proto3" json:"delegator_address,omitempty" yaml:"delegator_address"` +} + +func (m *MsgDisableTokenizeShares) Reset() { *m = MsgDisableTokenizeShares{} } +func (m *MsgDisableTokenizeShares) String() string { return proto.CompactTextString(m) } +func (*MsgDisableTokenizeShares) ProtoMessage() {} +func (*MsgDisableTokenizeShares) Descriptor() ([]byte, []int) { + return fileDescriptor_a63931950704005e, []int{8} +} +func (m *MsgDisableTokenizeShares) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgDisableTokenizeShares) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgDisableTokenizeShares.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 *MsgDisableTokenizeShares) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgDisableTokenizeShares.Merge(m, src) +} +func (m *MsgDisableTokenizeShares) XXX_Size() int { + return m.Size() +} +func (m *MsgDisableTokenizeShares) XXX_DiscardUnknown() { + xxx_messageInfo_MsgDisableTokenizeShares.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgDisableTokenizeShares proto.InternalMessageInfo + +// MsgDisableTokenizeSharesResponse defines the Msg/DisableTokenizeShares +// response type. +type MsgDisableTokenizeSharesResponse struct { +} + +func (m *MsgDisableTokenizeSharesResponse) Reset() { *m = MsgDisableTokenizeSharesResponse{} } +func (m *MsgDisableTokenizeSharesResponse) String() string { return proto.CompactTextString(m) } +func (*MsgDisableTokenizeSharesResponse) ProtoMessage() {} +func (*MsgDisableTokenizeSharesResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_a63931950704005e, []int{9} +} +func (m *MsgDisableTokenizeSharesResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgDisableTokenizeSharesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgDisableTokenizeSharesResponse.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 *MsgDisableTokenizeSharesResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgDisableTokenizeSharesResponse.Merge(m, src) +} +func (m *MsgDisableTokenizeSharesResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgDisableTokenizeSharesResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgDisableTokenizeSharesResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgDisableTokenizeSharesResponse proto.InternalMessageInfo + +// MsgEnableTokenizeShares re-enables tokenization of shares for a given address +type MsgEnableTokenizeShares struct { + DelegatorAddress string `protobuf:"bytes,1,opt,name=delegator_address,json=delegatorAddress,proto3" json:"delegator_address,omitempty" yaml:"delegator_address"` +} + +func (m *MsgEnableTokenizeShares) Reset() { *m = MsgEnableTokenizeShares{} } +func (m *MsgEnableTokenizeShares) String() string { return proto.CompactTextString(m) } +func (*MsgEnableTokenizeShares) ProtoMessage() {} +func (*MsgEnableTokenizeShares) Descriptor() ([]byte, []int) { + return fileDescriptor_a63931950704005e, []int{10} +} +func (m *MsgEnableTokenizeShares) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgEnableTokenizeShares) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgEnableTokenizeShares.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 *MsgEnableTokenizeShares) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgEnableTokenizeShares.Merge(m, src) +} +func (m *MsgEnableTokenizeShares) XXX_Size() int { + return m.Size() +} +func (m *MsgEnableTokenizeShares) XXX_DiscardUnknown() { + xxx_messageInfo_MsgEnableTokenizeShares.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgEnableTokenizeShares proto.InternalMessageInfo + +// MsgEnableTokenizeSharesResponse defines the Msg/EnableTokenizeShares response +// type. +type MsgEnableTokenizeSharesResponse struct { + CompletionTime time.Time `protobuf:"bytes,1,opt,name=completion_time,json=completionTime,proto3,stdtime" json:"completion_time"` +} + +func (m *MsgEnableTokenizeSharesResponse) Reset() { *m = MsgEnableTokenizeSharesResponse{} } +func (m *MsgEnableTokenizeSharesResponse) String() string { return proto.CompactTextString(m) } +func (*MsgEnableTokenizeSharesResponse) ProtoMessage() {} +func (*MsgEnableTokenizeSharesResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_a63931950704005e, []int{11} +} +func (m *MsgEnableTokenizeSharesResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgEnableTokenizeSharesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgEnableTokenizeSharesResponse.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 *MsgEnableTokenizeSharesResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgEnableTokenizeSharesResponse.Merge(m, src) +} +func (m *MsgEnableTokenizeSharesResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgEnableTokenizeSharesResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgEnableTokenizeSharesResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgEnableTokenizeSharesResponse proto.InternalMessageInfo + +func (m *MsgEnableTokenizeSharesResponse) GetCompletionTime() time.Time { + if m != nil { + return m.CompletionTime + } + return time.Time{} +} + +// MsgWithdrawTokenizeShareRecordReward withdraws tokenize share rewards for a +// specific record +type MsgWithdrawTokenizeShareRecordReward struct { + OwnerAddress string `protobuf:"bytes,1,opt,name=owner_address,json=ownerAddress,proto3" json:"owner_address,omitempty" yaml:"owner_address"` + RecordId uint64 `protobuf:"varint,2,opt,name=record_id,json=recordId,proto3" json:"record_id,omitempty"` +} + +func (m *MsgWithdrawTokenizeShareRecordReward) Reset() { *m = MsgWithdrawTokenizeShareRecordReward{} } +func (m *MsgWithdrawTokenizeShareRecordReward) String() string { return proto.CompactTextString(m) } +func (*MsgWithdrawTokenizeShareRecordReward) ProtoMessage() {} +func (*MsgWithdrawTokenizeShareRecordReward) Descriptor() ([]byte, []int) { + return fileDescriptor_a63931950704005e, []int{12} +} +func (m *MsgWithdrawTokenizeShareRecordReward) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgWithdrawTokenizeShareRecordReward) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgWithdrawTokenizeShareRecordReward.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 *MsgWithdrawTokenizeShareRecordReward) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgWithdrawTokenizeShareRecordReward.Merge(m, src) +} +func (m *MsgWithdrawTokenizeShareRecordReward) XXX_Size() int { + return m.Size() +} +func (m *MsgWithdrawTokenizeShareRecordReward) XXX_DiscardUnknown() { + xxx_messageInfo_MsgWithdrawTokenizeShareRecordReward.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgWithdrawTokenizeShareRecordReward proto.InternalMessageInfo + +// MsgWithdrawTokenizeShareRecordReward defines the +// Msg/WithdrawTokenizeShareRecordReward response type. +type MsgWithdrawTokenizeShareRecordRewardResponse struct { +} + +func (m *MsgWithdrawTokenizeShareRecordRewardResponse) Reset() { + *m = MsgWithdrawTokenizeShareRecordRewardResponse{} +} +func (m *MsgWithdrawTokenizeShareRecordRewardResponse) String() string { + return proto.CompactTextString(m) +} +func (*MsgWithdrawTokenizeShareRecordRewardResponse) ProtoMessage() {} +func (*MsgWithdrawTokenizeShareRecordRewardResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_a63931950704005e, []int{13} +} +func (m *MsgWithdrawTokenizeShareRecordRewardResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgWithdrawTokenizeShareRecordRewardResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgWithdrawTokenizeShareRecordRewardResponse.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 *MsgWithdrawTokenizeShareRecordRewardResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgWithdrawTokenizeShareRecordRewardResponse.Merge(m, src) +} +func (m *MsgWithdrawTokenizeShareRecordRewardResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgWithdrawTokenizeShareRecordRewardResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgWithdrawTokenizeShareRecordRewardResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgWithdrawTokenizeShareRecordRewardResponse proto.InternalMessageInfo + +// MsgWithdrawAllTokenizeShareRecordReward withdraws tokenize share rewards or +// all records owned by the designated owner +type MsgWithdrawAllTokenizeShareRecordReward struct { + OwnerAddress string `protobuf:"bytes,1,opt,name=owner_address,json=ownerAddress,proto3" json:"owner_address,omitempty" yaml:"owner_address"` +} + +func (m *MsgWithdrawAllTokenizeShareRecordReward) Reset() { + *m = MsgWithdrawAllTokenizeShareRecordReward{} +} +func (m *MsgWithdrawAllTokenizeShareRecordReward) String() string { return proto.CompactTextString(m) } +func (*MsgWithdrawAllTokenizeShareRecordReward) ProtoMessage() {} +func (*MsgWithdrawAllTokenizeShareRecordReward) Descriptor() ([]byte, []int) { + return fileDescriptor_a63931950704005e, []int{14} +} +func (m *MsgWithdrawAllTokenizeShareRecordReward) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgWithdrawAllTokenizeShareRecordReward) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgWithdrawAllTokenizeShareRecordReward.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 *MsgWithdrawAllTokenizeShareRecordReward) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgWithdrawAllTokenizeShareRecordReward.Merge(m, src) +} +func (m *MsgWithdrawAllTokenizeShareRecordReward) XXX_Size() int { + return m.Size() +} +func (m *MsgWithdrawAllTokenizeShareRecordReward) XXX_DiscardUnknown() { + xxx_messageInfo_MsgWithdrawAllTokenizeShareRecordReward.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgWithdrawAllTokenizeShareRecordReward proto.InternalMessageInfo + +// MsgWithdrawAllTokenizeShareRecordRewardResponse defines the +// Msg/WithdrawTokenizeShareRecordReward response type. +type MsgWithdrawAllTokenizeShareRecordRewardResponse struct { +} + +func (m *MsgWithdrawAllTokenizeShareRecordRewardResponse) Reset() { + *m = MsgWithdrawAllTokenizeShareRecordRewardResponse{} +} +func (m *MsgWithdrawAllTokenizeShareRecordRewardResponse) String() string { + return proto.CompactTextString(m) +} +func (*MsgWithdrawAllTokenizeShareRecordRewardResponse) ProtoMessage() {} +func (*MsgWithdrawAllTokenizeShareRecordRewardResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_a63931950704005e, []int{15} +} +func (m *MsgWithdrawAllTokenizeShareRecordRewardResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgWithdrawAllTokenizeShareRecordRewardResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgWithdrawAllTokenizeShareRecordRewardResponse.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 *MsgWithdrawAllTokenizeShareRecordRewardResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgWithdrawAllTokenizeShareRecordRewardResponse.Merge(m, src) +} +func (m *MsgWithdrawAllTokenizeShareRecordRewardResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgWithdrawAllTokenizeShareRecordRewardResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgWithdrawAllTokenizeShareRecordRewardResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgWithdrawAllTokenizeShareRecordRewardResponse proto.InternalMessageInfo + +func init() { + proto.RegisterType((*MsgUpdateParams)(nil), "kyve.liquid.v1beta1.MsgUpdateParams") + proto.RegisterType((*MsgUpdateParamsResponse)(nil), "kyve.liquid.v1beta1.MsgUpdateParamsResponse") + proto.RegisterType((*MsgTokenizeShares)(nil), "kyve.liquid.v1beta1.MsgTokenizeShares") + proto.RegisterType((*MsgTokenizeSharesResponse)(nil), "kyve.liquid.v1beta1.MsgTokenizeSharesResponse") + proto.RegisterType((*MsgRedeemTokensForShares)(nil), "kyve.liquid.v1beta1.MsgRedeemTokensForShares") + proto.RegisterType((*MsgRedeemTokensForSharesResponse)(nil), "kyve.liquid.v1beta1.MsgRedeemTokensForSharesResponse") + proto.RegisterType((*MsgTransferTokenizeShareRecord)(nil), "kyve.liquid.v1beta1.MsgTransferTokenizeShareRecord") + proto.RegisterType((*MsgTransferTokenizeShareRecordResponse)(nil), "kyve.liquid.v1beta1.MsgTransferTokenizeShareRecordResponse") + proto.RegisterType((*MsgDisableTokenizeShares)(nil), "kyve.liquid.v1beta1.MsgDisableTokenizeShares") + proto.RegisterType((*MsgDisableTokenizeSharesResponse)(nil), "kyve.liquid.v1beta1.MsgDisableTokenizeSharesResponse") + proto.RegisterType((*MsgEnableTokenizeShares)(nil), "kyve.liquid.v1beta1.MsgEnableTokenizeShares") + proto.RegisterType((*MsgEnableTokenizeSharesResponse)(nil), "kyve.liquid.v1beta1.MsgEnableTokenizeSharesResponse") + proto.RegisterType((*MsgWithdrawTokenizeShareRecordReward)(nil), "kyve.liquid.v1beta1.MsgWithdrawTokenizeShareRecordReward") + proto.RegisterType((*MsgWithdrawTokenizeShareRecordRewardResponse)(nil), "kyve.liquid.v1beta1.MsgWithdrawTokenizeShareRecordRewardResponse") + proto.RegisterType((*MsgWithdrawAllTokenizeShareRecordReward)(nil), "kyve.liquid.v1beta1.MsgWithdrawAllTokenizeShareRecordReward") + proto.RegisterType((*MsgWithdrawAllTokenizeShareRecordRewardResponse)(nil), "kyve.liquid.v1beta1.MsgWithdrawAllTokenizeShareRecordRewardResponse") +} + +func init() { proto.RegisterFile("kyve/liquid/v1beta1/tx.proto", fileDescriptor_a63931950704005e) } + +var fileDescriptor_a63931950704005e = []byte{ + // 1044 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x57, 0x4d, 0x6f, 0x1b, 0x45, + 0x18, 0xf6, 0x24, 0x21, 0x8a, 0x87, 0xd2, 0x36, 0xdb, 0xb4, 0xdd, 0xac, 0x83, 0x1d, 0x96, 0xa8, + 0x84, 0x90, 0xee, 0x2a, 0x29, 0x50, 0xd5, 0xe5, 0x2b, 0xa6, 0x41, 0x54, 0x95, 0x01, 0x6d, 0x03, + 0x08, 0x38, 0x58, 0x63, 0xef, 0x74, 0xbd, 0xca, 0xee, 0x8e, 0x99, 0x59, 0xc7, 0x4d, 0x25, 0x24, + 0xc4, 0x09, 0x71, 0xa1, 0x3f, 0xa1, 0x1c, 0x10, 0x88, 0x53, 0x0e, 0x20, 0xc4, 0x3f, 0xa8, 0x04, + 0x87, 0xc2, 0x89, 0x53, 0xa8, 0x92, 0x43, 0x38, 0xf7, 0x17, 0xa0, 0xd9, 0x9d, 0x5d, 0x7f, 0xed, + 0xfa, 0xa3, 0x25, 0x97, 0xc4, 0x33, 0xef, 0xf3, 0xbe, 0xf3, 0x3e, 0xcf, 0x3c, 0x33, 0x63, 0xc3, + 0x85, 0xed, 0xdd, 0x1d, 0xac, 0x3b, 0xf6, 0xe7, 0x4d, 0xdb, 0xd4, 0x77, 0xd6, 0xaa, 0xd8, 0x47, + 0x6b, 0xba, 0x7f, 0x5b, 0x6b, 0x50, 0xe2, 0x13, 0xe9, 0x0c, 0x8f, 0x6a, 0x61, 0x54, 0x13, 0x51, + 0xa5, 0x60, 0x11, 0x62, 0x39, 0x58, 0x0f, 0x20, 0xd5, 0xe6, 0x2d, 0xdd, 0xb7, 0x5d, 0xcc, 0x7c, + 0xe4, 0x36, 0xc2, 0x2c, 0x65, 0xce, 0x22, 0x16, 0x09, 0x3e, 0xea, 0xfc, 0x93, 0x98, 0x9d, 0xaf, + 0x11, 0xe6, 0x12, 0x56, 0x09, 0x03, 0xe1, 0x40, 0x84, 0xf2, 0xe1, 0x48, 0xaf, 0x22, 0x86, 0xe3, + 0x26, 0x6a, 0xc4, 0xf6, 0x44, 0x7c, 0x31, 0xa9, 0x49, 0xd1, 0x55, 0x88, 0x38, 0x2f, 0x2a, 0xb8, + 0xcc, 0xd2, 0x77, 0xd6, 0xf8, 0x3f, 0x11, 0x98, 0x45, 0xae, 0xed, 0x11, 0x3d, 0xf8, 0x1b, 0x4e, + 0xa9, 0xbf, 0x01, 0x78, 0xaa, 0xcc, 0xac, 0x0f, 0x1b, 0x26, 0xf2, 0xf1, 0x07, 0x88, 0x22, 0x97, + 0x49, 0xaf, 0xc2, 0x2c, 0x6a, 0xfa, 0x75, 0x42, 0x6d, 0x7f, 0x57, 0x06, 0x8b, 0x60, 0x39, 0x5b, + 0x92, 0xff, 0xfa, 0xf9, 0xe2, 0x9c, 0x68, 0x73, 0xc3, 0x34, 0x29, 0x66, 0xec, 0xa6, 0x4f, 0x6d, + 0xcf, 0x32, 0xda, 0x50, 0xe9, 0x0d, 0x38, 0xdd, 0x08, 0x2a, 0xc8, 0x13, 0x8b, 0x60, 0xf9, 0xe9, + 0xf5, 0x9c, 0x96, 0xa0, 0x98, 0x16, 0x2e, 0x52, 0xca, 0xde, 0xdf, 0x2f, 0x64, 0x7e, 0x3c, 0xda, + 0x5b, 0x01, 0x86, 0xc8, 0x2a, 0x6a, 0x5f, 0x1d, 0xed, 0xad, 0xb4, 0xeb, 0x7d, 0x73, 0xb4, 0xb7, + 0x92, 0xb3, 0x90, 0x8d, 0x22, 0xb2, 0x3d, 0x7d, 0xaa, 0xf3, 0xf0, 0x7c, 0xcf, 0x94, 0x81, 0x59, + 0x83, 0x78, 0x0c, 0xab, 0x7f, 0x4e, 0xc0, 0xd9, 0x32, 0xb3, 0xb6, 0xc8, 0x36, 0xf6, 0xec, 0x3b, + 0xf8, 0x66, 0x1d, 0x51, 0xcc, 0xa4, 0xeb, 0x70, 0xd6, 0xc4, 0x0e, 0xb6, 0x90, 0x4f, 0x68, 0x05, + 0x85, 0x34, 0x04, 0xc1, 0x85, 0x47, 0xfb, 0x05, 0x79, 0x17, 0xb9, 0x4e, 0x51, 0xed, 0x83, 0xa8, + 0xc6, 0xe9, 0x78, 0x4e, 0x90, 0xe7, 0xa5, 0x76, 0x90, 0x63, 0x9b, 0x5d, 0xa5, 0x26, 0x7a, 0x4b, + 0xf5, 0x41, 0x54, 0xe3, 0x74, 0x3c, 0x17, 0x95, 0xba, 0x0c, 0xa7, 0x91, 0x4b, 0x9a, 0x9e, 0x2f, + 0x4f, 0x06, 0xb2, 0xcd, 0x6b, 0x42, 0x68, 0xee, 0x80, 0x58, 0xb6, 0xb7, 0x89, 0xed, 0x95, 0xa6, + 0xb8, 0x68, 0x86, 0x80, 0x4b, 0xeb, 0xf0, 0xac, 0x2f, 0x08, 0x9a, 0x15, 0xc6, 0x29, 0x56, 0x48, + 0xcb, 0xc3, 0x54, 0x9e, 0xe2, 0x7d, 0x18, 0x67, 0xe2, 0x60, 0x40, 0xff, 0x7d, 0x1e, 0x2a, 0x5e, + 0xf9, 0xfa, 0x5e, 0x21, 0xf3, 0xef, 0xbd, 0x42, 0x86, 0x6b, 0xdd, 0xaf, 0x06, 0xd7, 0xfc, 0x5c, + 0xa0, 0x79, 0x9f, 0x7a, 0xea, 0x16, 0x9c, 0xef, 0x9b, 0x8c, 0x04, 0xef, 0x20, 0x01, 0xc6, 0x22, + 0xa1, 0x3e, 0x04, 0x50, 0x2e, 0x33, 0xcb, 0xc0, 0x26, 0xc6, 0x6e, 0x50, 0x9c, 0xbd, 0x43, 0xe8, + 0xff, 0xbf, 0x61, 0xed, 0x06, 0x27, 0xc6, 0x6a, 0xb0, 0xf8, 0xd6, 0x70, 0xc5, 0x9e, 0x8d, 0x14, + 0x4b, 0x64, 0xa1, 0x7e, 0x06, 0x17, 0xd3, 0x62, 0x4f, 0xae, 0xdf, 0xef, 0x00, 0xe6, 0xf9, 0xb6, + 0x50, 0xe4, 0xb1, 0x5b, 0x98, 0x76, 0x6d, 0x8f, 0x81, 0x6b, 0x84, 0x9a, 0xd2, 0x65, 0x28, 0x47, + 0x56, 0x10, 0x36, 0xa1, 0x41, 0xa0, 0x62, 0x9b, 0xc1, 0x6a, 0x53, 0x46, 0xec, 0xa3, 0x8e, 0xb4, + 0xeb, 0xa6, 0x74, 0x0e, 0x4e, 0x33, 0xec, 0x99, 0x98, 0x86, 0xce, 0x36, 0xc4, 0x48, 0xca, 0xc1, + 0xac, 0x87, 0x5b, 0xc2, 0x6c, 0x93, 0x41, 0x68, 0xc6, 0xc3, 0xad, 0xd0, 0x61, 0x57, 0x3b, 0xf5, + 0x12, 0x19, 0x5c, 0xa4, 0xe7, 0x63, 0x5b, 0xa5, 0xb7, 0xaa, 0x2e, 0xc3, 0x0b, 0x83, 0x11, 0xf1, + 0x09, 0xff, 0x21, 0xf4, 0xcd, 0x35, 0x9b, 0xa1, 0xaa, 0x83, 0x8f, 0xed, 0xa0, 0x8f, 0xb5, 0xfd, + 0x89, 0xcd, 0xa8, 0x6a, 0xb0, 0xfd, 0x89, 0xb1, 0x98, 0xcd, 0xf7, 0x20, 0xb8, 0xcb, 0x36, 0xbd, + 0xe3, 0x25, 0xf3, 0xe6, 0x70, 0x32, 0x0b, 0x11, 0x99, 0xa4, 0x5e, 0xd4, 0x06, 0x2c, 0xa4, 0x84, + 0x62, 0x27, 0x97, 0xe1, 0xa9, 0x1a, 0x71, 0x1b, 0x0e, 0xf6, 0x6d, 0xe2, 0x55, 0xf8, 0x73, 0x28, + 0x2c, 0xad, 0x68, 0xe1, 0x5b, 0xa9, 0x45, 0x6f, 0xa5, 0xb6, 0x15, 0xbd, 0x95, 0xa5, 0x19, 0xee, + 0xe9, 0xbb, 0xff, 0x14, 0x80, 0x71, 0xb2, 0x9d, 0xcc, 0xc3, 0xea, 0x1f, 0x00, 0x2e, 0x95, 0x99, + 0xf5, 0xb1, 0xed, 0xd7, 0x4d, 0x8a, 0x5a, 0x89, 0x96, 0x68, 0x21, 0x6a, 0x4a, 0xaf, 0xc3, 0x67, + 0x02, 0x43, 0xf6, 0x48, 0x24, 0x3f, 0xda, 0x2f, 0xcc, 0x85, 0x12, 0x75, 0x85, 0x55, 0xe3, 0x44, + 0x30, 0x8e, 0xee, 0x87, 0x1c, 0xcc, 0xb6, 0x4f, 0xc5, 0x44, 0x70, 0x2a, 0x66, 0xa8, 0x38, 0x08, + 0xc5, 0x77, 0x3b, 0x75, 0xeb, 0x5e, 0x86, 0x6b, 0xf6, 0x62, 0xa4, 0xd9, 0xd0, 0x2e, 0x55, 0x0d, + 0xae, 0x8e, 0x82, 0x8b, 0x8d, 0xf1, 0x0b, 0x80, 0x2f, 0x74, 0x24, 0x6c, 0x38, 0xce, 0x71, 0x29, + 0x50, 0xbc, 0x31, 0x98, 0xe4, 0x6a, 0x2f, 0xc9, 0x41, 0xbd, 0xa8, 0x6b, 0x70, 0x54, 0x68, 0x44, + 0x75, 0xfd, 0xd7, 0x19, 0x38, 0x59, 0x66, 0x96, 0x54, 0x85, 0x27, 0xba, 0xbe, 0x8e, 0x2c, 0x25, + 0x7e, 0x8d, 0xe8, 0x79, 0xf9, 0x95, 0xd5, 0x51, 0x50, 0xb1, 0x49, 0xeb, 0xf0, 0x64, 0xcf, 0x29, + 0xbb, 0x90, 0x96, 0xdf, 0x8d, 0x53, 0xb4, 0xd1, 0x70, 0xf1, 0x4a, 0x5f, 0xc0, 0xb3, 0xc9, 0x6f, + 0xdb, 0xc5, 0xb4, 0x42, 0x89, 0x70, 0xe5, 0x95, 0xb1, 0xe0, 0xf1, 0xf2, 0xdf, 0x02, 0x98, 0x1b, + 0xf4, 0x36, 0x5c, 0x4a, 0xa5, 0x93, 0x9e, 0xa4, 0x5c, 0x7d, 0x8c, 0xa4, 0x4e, 0x41, 0x92, 0x2f, + 0xed, 0x54, 0x41, 0x12, 0xe1, 0xe9, 0x82, 0x0c, 0xbc, 0x69, 0xa5, 0x3b, 0x70, 0x2e, 0xf1, 0x96, + 0x4d, 0xf5, 0x4f, 0x12, 0x5a, 0x79, 0x79, 0x1c, 0x74, 0xbc, 0xf6, 0x77, 0x00, 0x3e, 0x37, 0xfc, + 0x22, 0xbb, 0x92, 0x56, 0x7b, 0x68, 0xaa, 0xb2, 0xf1, 0xd8, 0xa9, 0x71, 0x8f, 0x3f, 0x01, 0xb8, + 0x34, 0xd2, 0x6d, 0xf3, 0xda, 0xb0, 0xb5, 0x06, 0x65, 0x2b, 0xd7, 0x9e, 0x24, 0x3b, 0x6a, 0x56, + 0x79, 0xea, 0x4b, 0xfe, 0x03, 0xa2, 0xb4, 0x79, 0xff, 0x20, 0x0f, 0x1e, 0x1c, 0xe4, 0xc1, 0xc3, + 0x83, 0x3c, 0xb8, 0x7b, 0x98, 0xcf, 0x3c, 0x38, 0xcc, 0x67, 0xfe, 0x3e, 0xcc, 0x67, 0x3e, 0x7d, + 0xc9, 0xb2, 0xfd, 0x7a, 0xb3, 0xaa, 0xd5, 0x88, 0xab, 0xdf, 0xf8, 0xe4, 0xa3, 0xcd, 0xf7, 0xb0, + 0xdf, 0x22, 0x74, 0x5b, 0xaf, 0xd5, 0x91, 0xed, 0xe9, 0xb7, 0xa3, 0x5f, 0x16, 0xfe, 0x6e, 0x03, + 0xb3, 0xea, 0x74, 0xf0, 0x30, 0x5d, 0xfa, 0x2f, 0x00, 0x00, 0xff, 0xff, 0x86, 0xfd, 0x02, 0xf2, + 0x07, 0x0e, 0x00, 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// MsgClient is the client API for Msg service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type MsgClient interface { + // UpdateParams defines an operation for updating the x/liquid module + // parameters. + UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error) + // TokenizeShares defines a method for tokenizing shares from a validator. + TokenizeShares(ctx context.Context, in *MsgTokenizeShares, opts ...grpc.CallOption) (*MsgTokenizeSharesResponse, error) + // RedeemTokensForShares defines a method for redeeming tokens from a + // validator for shares. + RedeemTokensForShares(ctx context.Context, in *MsgRedeemTokensForShares, opts ...grpc.CallOption) (*MsgRedeemTokensForSharesResponse, error) + // TransferTokenizeShareRecord defines a method to transfer ownership of + // TokenizeShareRecord + TransferTokenizeShareRecord(ctx context.Context, in *MsgTransferTokenizeShareRecord, opts ...grpc.CallOption) (*MsgTransferTokenizeShareRecordResponse, error) + // DisableTokenizeShares defines a method to prevent the tokenization of an + // addresses stake + DisableTokenizeShares(ctx context.Context, in *MsgDisableTokenizeShares, opts ...grpc.CallOption) (*MsgDisableTokenizeSharesResponse, error) + // EnableTokenizeShares defines a method to re-enable the tokenization of an + // addresseses stake after it has been disabled + EnableTokenizeShares(ctx context.Context, in *MsgEnableTokenizeShares, opts ...grpc.CallOption) (*MsgEnableTokenizeSharesResponse, error) + // WithdrawTokenizeShareRecordReward defines a method to withdraw reward for + // an owning TokenizeShareRecord + WithdrawTokenizeShareRecordReward(ctx context.Context, in *MsgWithdrawTokenizeShareRecordReward, opts ...grpc.CallOption) (*MsgWithdrawTokenizeShareRecordRewardResponse, error) + // WithdrawAllTokenizeShareRecordReward defines a method to withdraw reward + // for all owning TokenizeShareRecord + WithdrawAllTokenizeShareRecordReward(ctx context.Context, in *MsgWithdrawAllTokenizeShareRecordReward, opts ...grpc.CallOption) (*MsgWithdrawAllTokenizeShareRecordRewardResponse, error) +} + +type msgClient struct { + cc grpc1.ClientConn +} + +func NewMsgClient(cc grpc1.ClientConn) MsgClient { + return &msgClient{cc} +} + +func (c *msgClient) UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error) { + out := new(MsgUpdateParamsResponse) + err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Msg/UpdateParams", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgClient) TokenizeShares(ctx context.Context, in *MsgTokenizeShares, opts ...grpc.CallOption) (*MsgTokenizeSharesResponse, error) { + out := new(MsgTokenizeSharesResponse) + err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Msg/TokenizeShares", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgClient) RedeemTokensForShares(ctx context.Context, in *MsgRedeemTokensForShares, opts ...grpc.CallOption) (*MsgRedeemTokensForSharesResponse, error) { + out := new(MsgRedeemTokensForSharesResponse) + err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Msg/RedeemTokensForShares", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgClient) TransferTokenizeShareRecord(ctx context.Context, in *MsgTransferTokenizeShareRecord, opts ...grpc.CallOption) (*MsgTransferTokenizeShareRecordResponse, error) { + out := new(MsgTransferTokenizeShareRecordResponse) + err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Msg/TransferTokenizeShareRecord", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgClient) DisableTokenizeShares(ctx context.Context, in *MsgDisableTokenizeShares, opts ...grpc.CallOption) (*MsgDisableTokenizeSharesResponse, error) { + out := new(MsgDisableTokenizeSharesResponse) + err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Msg/DisableTokenizeShares", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgClient) EnableTokenizeShares(ctx context.Context, in *MsgEnableTokenizeShares, opts ...grpc.CallOption) (*MsgEnableTokenizeSharesResponse, error) { + out := new(MsgEnableTokenizeSharesResponse) + err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Msg/EnableTokenizeShares", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgClient) WithdrawTokenizeShareRecordReward(ctx context.Context, in *MsgWithdrawTokenizeShareRecordReward, opts ...grpc.CallOption) (*MsgWithdrawTokenizeShareRecordRewardResponse, error) { + out := new(MsgWithdrawTokenizeShareRecordRewardResponse) + err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Msg/WithdrawTokenizeShareRecordReward", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgClient) WithdrawAllTokenizeShareRecordReward(ctx context.Context, in *MsgWithdrawAllTokenizeShareRecordReward, opts ...grpc.CallOption) (*MsgWithdrawAllTokenizeShareRecordRewardResponse, error) { + out := new(MsgWithdrawAllTokenizeShareRecordRewardResponse) + err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Msg/WithdrawAllTokenizeShareRecordReward", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// MsgServer is the server API for Msg service. +type MsgServer interface { + // UpdateParams defines an operation for updating the x/liquid module + // parameters. + UpdateParams(context.Context, *MsgUpdateParams) (*MsgUpdateParamsResponse, error) + // TokenizeShares defines a method for tokenizing shares from a validator. + TokenizeShares(context.Context, *MsgTokenizeShares) (*MsgTokenizeSharesResponse, error) + // RedeemTokensForShares defines a method for redeeming tokens from a + // validator for shares. + RedeemTokensForShares(context.Context, *MsgRedeemTokensForShares) (*MsgRedeemTokensForSharesResponse, error) + // TransferTokenizeShareRecord defines a method to transfer ownership of + // TokenizeShareRecord + TransferTokenizeShareRecord(context.Context, *MsgTransferTokenizeShareRecord) (*MsgTransferTokenizeShareRecordResponse, error) + // DisableTokenizeShares defines a method to prevent the tokenization of an + // addresses stake + DisableTokenizeShares(context.Context, *MsgDisableTokenizeShares) (*MsgDisableTokenizeSharesResponse, error) + // EnableTokenizeShares defines a method to re-enable the tokenization of an + // addresseses stake after it has been disabled + EnableTokenizeShares(context.Context, *MsgEnableTokenizeShares) (*MsgEnableTokenizeSharesResponse, error) + // WithdrawTokenizeShareRecordReward defines a method to withdraw reward for + // an owning TokenizeShareRecord + WithdrawTokenizeShareRecordReward(context.Context, *MsgWithdrawTokenizeShareRecordReward) (*MsgWithdrawTokenizeShareRecordRewardResponse, error) + // WithdrawAllTokenizeShareRecordReward defines a method to withdraw reward + // for all owning TokenizeShareRecord + WithdrawAllTokenizeShareRecordReward(context.Context, *MsgWithdrawAllTokenizeShareRecordReward) (*MsgWithdrawAllTokenizeShareRecordRewardResponse, error) +} + +// UnimplementedMsgServer can be embedded to have forward compatible implementations. +type UnimplementedMsgServer struct { +} + +func (*UnimplementedMsgServer) UpdateParams(ctx context.Context, req *MsgUpdateParams) (*MsgUpdateParamsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method UpdateParams not implemented") +} +func (*UnimplementedMsgServer) TokenizeShares(ctx context.Context, req *MsgTokenizeShares) (*MsgTokenizeSharesResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method TokenizeShares not implemented") +} +func (*UnimplementedMsgServer) RedeemTokensForShares(ctx context.Context, req *MsgRedeemTokensForShares) (*MsgRedeemTokensForSharesResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method RedeemTokensForShares not implemented") +} +func (*UnimplementedMsgServer) TransferTokenizeShareRecord(ctx context.Context, req *MsgTransferTokenizeShareRecord) (*MsgTransferTokenizeShareRecordResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method TransferTokenizeShareRecord not implemented") +} +func (*UnimplementedMsgServer) DisableTokenizeShares(ctx context.Context, req *MsgDisableTokenizeShares) (*MsgDisableTokenizeSharesResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method DisableTokenizeShares not implemented") +} +func (*UnimplementedMsgServer) EnableTokenizeShares(ctx context.Context, req *MsgEnableTokenizeShares) (*MsgEnableTokenizeSharesResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method EnableTokenizeShares not implemented") +} +func (*UnimplementedMsgServer) WithdrawTokenizeShareRecordReward(ctx context.Context, req *MsgWithdrawTokenizeShareRecordReward) (*MsgWithdrawTokenizeShareRecordRewardResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method WithdrawTokenizeShareRecordReward not implemented") +} +func (*UnimplementedMsgServer) WithdrawAllTokenizeShareRecordReward(ctx context.Context, req *MsgWithdrawAllTokenizeShareRecordReward) (*MsgWithdrawAllTokenizeShareRecordRewardResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method WithdrawAllTokenizeShareRecordReward not implemented") +} + +func RegisterMsgServer(s grpc1.Server, srv MsgServer) { + s.RegisterService(&_Msg_serviceDesc, srv) +} + +func _Msg_UpdateParams_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgUpdateParams) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).UpdateParams(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/kyve.liquid.v1beta1.Msg/UpdateParams", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).UpdateParams(ctx, req.(*MsgUpdateParams)) + } + return interceptor(ctx, in, info, handler) +} + +func _Msg_TokenizeShares_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgTokenizeShares) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).TokenizeShares(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/kyve.liquid.v1beta1.Msg/TokenizeShares", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).TokenizeShares(ctx, req.(*MsgTokenizeShares)) + } + return interceptor(ctx, in, info, handler) +} + +func _Msg_RedeemTokensForShares_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgRedeemTokensForShares) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).RedeemTokensForShares(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/kyve.liquid.v1beta1.Msg/RedeemTokensForShares", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).RedeemTokensForShares(ctx, req.(*MsgRedeemTokensForShares)) + } + return interceptor(ctx, in, info, handler) +} + +func _Msg_TransferTokenizeShareRecord_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgTransferTokenizeShareRecord) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).TransferTokenizeShareRecord(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/kyve.liquid.v1beta1.Msg/TransferTokenizeShareRecord", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).TransferTokenizeShareRecord(ctx, req.(*MsgTransferTokenizeShareRecord)) + } + return interceptor(ctx, in, info, handler) +} + +func _Msg_DisableTokenizeShares_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgDisableTokenizeShares) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).DisableTokenizeShares(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/kyve.liquid.v1beta1.Msg/DisableTokenizeShares", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).DisableTokenizeShares(ctx, req.(*MsgDisableTokenizeShares)) + } + return interceptor(ctx, in, info, handler) +} + +func _Msg_EnableTokenizeShares_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgEnableTokenizeShares) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).EnableTokenizeShares(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/kyve.liquid.v1beta1.Msg/EnableTokenizeShares", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).EnableTokenizeShares(ctx, req.(*MsgEnableTokenizeShares)) + } + return interceptor(ctx, in, info, handler) +} + +func _Msg_WithdrawTokenizeShareRecordReward_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgWithdrawTokenizeShareRecordReward) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).WithdrawTokenizeShareRecordReward(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/kyve.liquid.v1beta1.Msg/WithdrawTokenizeShareRecordReward", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).WithdrawTokenizeShareRecordReward(ctx, req.(*MsgWithdrawTokenizeShareRecordReward)) + } + return interceptor(ctx, in, info, handler) +} + +func _Msg_WithdrawAllTokenizeShareRecordReward_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgWithdrawAllTokenizeShareRecordReward) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).WithdrawAllTokenizeShareRecordReward(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/kyve.liquid.v1beta1.Msg/WithdrawAllTokenizeShareRecordReward", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).WithdrawAllTokenizeShareRecordReward(ctx, req.(*MsgWithdrawAllTokenizeShareRecordReward)) + } + return interceptor(ctx, in, info, handler) +} + +var Msg_serviceDesc = _Msg_serviceDesc +var _Msg_serviceDesc = grpc.ServiceDesc{ + ServiceName: "kyve.liquid.v1beta1.Msg", + HandlerType: (*MsgServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "UpdateParams", + Handler: _Msg_UpdateParams_Handler, + }, + { + MethodName: "TokenizeShares", + Handler: _Msg_TokenizeShares_Handler, + }, + { + MethodName: "RedeemTokensForShares", + Handler: _Msg_RedeemTokensForShares_Handler, + }, + { + MethodName: "TransferTokenizeShareRecord", + Handler: _Msg_TransferTokenizeShareRecord_Handler, + }, + { + MethodName: "DisableTokenizeShares", + Handler: _Msg_DisableTokenizeShares_Handler, + }, + { + MethodName: "EnableTokenizeShares", + Handler: _Msg_EnableTokenizeShares_Handler, + }, + { + MethodName: "WithdrawTokenizeShareRecordReward", + Handler: _Msg_WithdrawTokenizeShareRecordReward_Handler, + }, + { + MethodName: "WithdrawAllTokenizeShareRecordReward", + Handler: _Msg_WithdrawAllTokenizeShareRecordReward_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "kyve/liquid/v1beta1/tx.proto", +} + +func (m *MsgUpdateParams) 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 *MsgUpdateParams) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgUpdateParams) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Params.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + if len(m.Authority) > 0 { + i -= len(m.Authority) + copy(dAtA[i:], m.Authority) + i = encodeVarintTx(dAtA, i, uint64(len(m.Authority))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgUpdateParamsResponse) 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 *MsgUpdateParamsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgUpdateParamsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *MsgTokenizeShares) 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 *MsgTokenizeShares) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgTokenizeShares) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.TokenizedShareOwner) > 0 { + i -= len(m.TokenizedShareOwner) + copy(dAtA[i:], m.TokenizedShareOwner) + i = encodeVarintTx(dAtA, i, uint64(len(m.TokenizedShareOwner))) + i-- + dAtA[i] = 0x22 + } + { + size, err := m.Amount.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + if len(m.ValidatorAddress) > 0 { + i -= len(m.ValidatorAddress) + copy(dAtA[i:], m.ValidatorAddress) + i = encodeVarintTx(dAtA, i, uint64(len(m.ValidatorAddress))) + i-- + dAtA[i] = 0x12 + } + if len(m.DelegatorAddress) > 0 { + i -= len(m.DelegatorAddress) + copy(dAtA[i:], m.DelegatorAddress) + i = encodeVarintTx(dAtA, i, uint64(len(m.DelegatorAddress))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgTokenizeSharesResponse) 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 *MsgTokenizeSharesResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgTokenizeSharesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Amount.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *MsgRedeemTokensForShares) 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 *MsgRedeemTokensForShares) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgRedeemTokensForShares) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Amount.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + if len(m.DelegatorAddress) > 0 { + i -= len(m.DelegatorAddress) + copy(dAtA[i:], m.DelegatorAddress) + i = encodeVarintTx(dAtA, i, uint64(len(m.DelegatorAddress))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgRedeemTokensForSharesResponse) 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 *MsgRedeemTokensForSharesResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgRedeemTokensForSharesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Amount.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *MsgTransferTokenizeShareRecord) 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 *MsgTransferTokenizeShareRecord) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgTransferTokenizeShareRecord) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.NewOwner) > 0 { + i -= len(m.NewOwner) + copy(dAtA[i:], m.NewOwner) + i = encodeVarintTx(dAtA, i, uint64(len(m.NewOwner))) + i-- + dAtA[i] = 0x1a + } + if len(m.Sender) > 0 { + i -= len(m.Sender) + copy(dAtA[i:], m.Sender) + i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) + i-- + dAtA[i] = 0x12 + } + if m.TokenizeShareRecordId != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.TokenizeShareRecordId)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *MsgTransferTokenizeShareRecordResponse) 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 *MsgTransferTokenizeShareRecordResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgTransferTokenizeShareRecordResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *MsgDisableTokenizeShares) 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 *MsgDisableTokenizeShares) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgDisableTokenizeShares) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.DelegatorAddress) > 0 { + i -= len(m.DelegatorAddress) + copy(dAtA[i:], m.DelegatorAddress) + i = encodeVarintTx(dAtA, i, uint64(len(m.DelegatorAddress))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgDisableTokenizeSharesResponse) 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 *MsgDisableTokenizeSharesResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgDisableTokenizeSharesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *MsgEnableTokenizeShares) 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 *MsgEnableTokenizeShares) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgEnableTokenizeShares) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.DelegatorAddress) > 0 { + i -= len(m.DelegatorAddress) + copy(dAtA[i:], m.DelegatorAddress) + i = encodeVarintTx(dAtA, i, uint64(len(m.DelegatorAddress))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgEnableTokenizeSharesResponse) 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 *MsgEnableTokenizeSharesResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgEnableTokenizeSharesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + n6, err6 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.CompletionTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.CompletionTime):]) + if err6 != nil { + return 0, err6 + } + i -= n6 + i = encodeVarintTx(dAtA, i, uint64(n6)) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *MsgWithdrawTokenizeShareRecordReward) 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 *MsgWithdrawTokenizeShareRecordReward) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgWithdrawTokenizeShareRecordReward) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.RecordId != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.RecordId)) + i-- + dAtA[i] = 0x10 + } + if len(m.OwnerAddress) > 0 { + i -= len(m.OwnerAddress) + copy(dAtA[i:], m.OwnerAddress) + i = encodeVarintTx(dAtA, i, uint64(len(m.OwnerAddress))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgWithdrawTokenizeShareRecordRewardResponse) 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 *MsgWithdrawTokenizeShareRecordRewardResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgWithdrawTokenizeShareRecordRewardResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *MsgWithdrawAllTokenizeShareRecordReward) 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 *MsgWithdrawAllTokenizeShareRecordReward) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgWithdrawAllTokenizeShareRecordReward) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.OwnerAddress) > 0 { + i -= len(m.OwnerAddress) + copy(dAtA[i:], m.OwnerAddress) + i = encodeVarintTx(dAtA, i, uint64(len(m.OwnerAddress))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgWithdrawAllTokenizeShareRecordRewardResponse) 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 *MsgWithdrawAllTokenizeShareRecordRewardResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgWithdrawAllTokenizeShareRecordRewardResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func encodeVarintTx(dAtA []byte, offset int, v uint64) int { + offset -= sovTx(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *MsgUpdateParams) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Authority) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = m.Params.Size() + n += 1 + l + sovTx(uint64(l)) + return n +} + +func (m *MsgUpdateParamsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgTokenizeShares) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.DelegatorAddress) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.ValidatorAddress) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = m.Amount.Size() + n += 1 + l + sovTx(uint64(l)) + l = len(m.TokenizedShareOwner) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgTokenizeSharesResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Amount.Size() + n += 1 + l + sovTx(uint64(l)) + return n +} + +func (m *MsgRedeemTokensForShares) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.DelegatorAddress) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = m.Amount.Size() + n += 1 + l + sovTx(uint64(l)) + return n +} + +func (m *MsgRedeemTokensForSharesResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Amount.Size() + n += 1 + l + sovTx(uint64(l)) + return n +} + +func (m *MsgTransferTokenizeShareRecord) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.TokenizeShareRecordId != 0 { + n += 1 + sovTx(uint64(m.TokenizeShareRecordId)) + } + l = len(m.Sender) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.NewOwner) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgTransferTokenizeShareRecordResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgDisableTokenizeShares) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.DelegatorAddress) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgDisableTokenizeSharesResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgEnableTokenizeShares) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.DelegatorAddress) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgEnableTokenizeSharesResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.CompletionTime) + n += 1 + l + sovTx(uint64(l)) + return n +} + +func (m *MsgWithdrawTokenizeShareRecordReward) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.OwnerAddress) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if m.RecordId != 0 { + n += 1 + sovTx(uint64(m.RecordId)) + } + return n +} + +func (m *MsgWithdrawTokenizeShareRecordRewardResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgWithdrawAllTokenizeShareRecordReward) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.OwnerAddress) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgWithdrawAllTokenizeShareRecordRewardResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func sovTx(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozTx(x uint64) (n int) { + return sovTx(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *MsgUpdateParams) 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 ErrIntOverflowTx + } + 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: MsgUpdateParams: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgUpdateParams: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Authority", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + 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 ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Authority = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgUpdateParamsResponse) 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 ErrIntOverflowTx + } + 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: MsgUpdateParamsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgUpdateParamsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgTokenizeShares) 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 ErrIntOverflowTx + } + 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: MsgTokenizeShares: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgTokenizeShares: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + 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 ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DelegatorAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + 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 ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ValidatorAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TokenizedShareOwner", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + 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 ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.TokenizedShareOwner = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgTokenizeSharesResponse) 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 ErrIntOverflowTx + } + 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: MsgTokenizeSharesResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgTokenizeSharesResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgRedeemTokensForShares) 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 ErrIntOverflowTx + } + 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: MsgRedeemTokensForShares: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgRedeemTokensForShares: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + 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 ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DelegatorAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgRedeemTokensForSharesResponse) 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 ErrIntOverflowTx + } + 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: MsgRedeemTokensForSharesResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgRedeemTokensForSharesResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgTransferTokenizeShareRecord) 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 ErrIntOverflowTx + } + 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: MsgTransferTokenizeShareRecord: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgTransferTokenizeShareRecord: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TokenizeShareRecordId", wireType) + } + m.TokenizeShareRecordId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.TokenizeShareRecordId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + 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 ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Sender = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NewOwner", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + 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 ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NewOwner = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgTransferTokenizeShareRecordResponse) 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 ErrIntOverflowTx + } + 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: MsgTransferTokenizeShareRecordResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgTransferTokenizeShareRecordResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgDisableTokenizeShares) 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 ErrIntOverflowTx + } + 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: MsgDisableTokenizeShares: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgDisableTokenizeShares: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + 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 ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DelegatorAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgDisableTokenizeSharesResponse) 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 ErrIntOverflowTx + } + 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: MsgDisableTokenizeSharesResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgDisableTokenizeSharesResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgEnableTokenizeShares) 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 ErrIntOverflowTx + } + 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: MsgEnableTokenizeShares: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgEnableTokenizeShares: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + 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 ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DelegatorAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgEnableTokenizeSharesResponse) 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 ErrIntOverflowTx + } + 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: MsgEnableTokenizeSharesResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgEnableTokenizeSharesResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CompletionTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.CompletionTime, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgWithdrawTokenizeShareRecordReward) 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 ErrIntOverflowTx + } + 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: MsgWithdrawTokenizeShareRecordReward: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgWithdrawTokenizeShareRecordReward: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OwnerAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + 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 ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.OwnerAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RecordId", wireType) + } + m.RecordId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RecordId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgWithdrawTokenizeShareRecordRewardResponse) 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 ErrIntOverflowTx + } + 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: MsgWithdrawTokenizeShareRecordRewardResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgWithdrawTokenizeShareRecordRewardResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgWithdrawAllTokenizeShareRecordReward) 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 ErrIntOverflowTx + } + 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: MsgWithdrawAllTokenizeShareRecordReward: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgWithdrawAllTokenizeShareRecordReward: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OwnerAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + 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 ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.OwnerAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgWithdrawAllTokenizeShareRecordRewardResponse) 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 ErrIntOverflowTx + } + 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: MsgWithdrawAllTokenizeShareRecordRewardResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgWithdrawAllTokenizeShareRecordRewardResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipTx(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTx + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTx + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTx + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthTx + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupTx + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthTx + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthTx = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowTx = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupTx = fmt.Errorf("proto: unexpected end of group") +) From e330b5e3a763e3dbd4eac926d2dce523d131e03a Mon Sep 17 00:00:00 2001 From: mbreithecker Date: Wed, 30 Jul 2025 13:58:46 +0200 Subject: [PATCH 2/8] chore: add license notice --- proto/kyve/liquid/LICENSE | 201 +++++++++++ proto/kyve/liquid/module/v1/module.proto | 26 ++ proto/kyve/liquid/v1beta1/genesis.proto | 52 +++ proto/kyve/liquid/v1beta1/liquid.proto | 102 ++++++ proto/kyve/liquid/v1beta1/query.proto | 246 +++++++++++++ proto/kyve/liquid/v1beta1/tx.proto | 206 +++++++++++ x/liquid/autocli.go | 5 + x/liquid/client/cli/tx.go | 5 + x/liquid/keeper/distribution.go | 5 + x/liquid/keeper/genesis.go | 5 + x/liquid/keeper/grpc_query.go | 5 + x/liquid/keeper/grpc_query_test.go | 5 + x/liquid/keeper/hooks.go | 5 + x/liquid/keeper/keeper.go | 5 + x/liquid/keeper/keeper_test.go | 5 + x/liquid/keeper/liquid_stake.go | 5 + x/liquid/keeper/liquid_stake_test.go | 5 + x/liquid/keeper/msg_server.go | 5 + x/liquid/keeper/params.go | 5 + x/liquid/keeper/tokenize_share_record.go | 5 + x/liquid/keeper/tokenize_share_record_test.go | 5 + x/liquid/module.go | 4 + x/liquid/types/genesis.pb.go | 87 +++-- x/liquid/types/liquid.pb.go | 127 ++++--- x/liquid/types/query.pb.go | 329 +++++++++--------- x/liquid/types/query.pb.gw.go | 26 +- x/liquid/types/tx.pb.go | 245 +++++++------ 27 files changed, 1317 insertions(+), 409 deletions(-) create mode 100644 proto/kyve/liquid/LICENSE create mode 100644 proto/kyve/liquid/module/v1/module.proto create mode 100644 proto/kyve/liquid/v1beta1/genesis.proto create mode 100644 proto/kyve/liquid/v1beta1/liquid.proto create mode 100644 proto/kyve/liquid/v1beta1/query.proto create mode 100644 proto/kyve/liquid/v1beta1/tx.proto diff --git a/proto/kyve/liquid/LICENSE b/proto/kyve/liquid/LICENSE new file mode 100644 index 00000000..b00fda25 --- /dev/null +++ b/proto/kyve/liquid/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright 2016 the Gaia authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. \ No newline at end of file diff --git a/proto/kyve/liquid/module/v1/module.proto b/proto/kyve/liquid/module/v1/module.proto new file mode 100644 index 00000000..fa10a2cb --- /dev/null +++ b/proto/kyve/liquid/module/v1/module.proto @@ -0,0 +1,26 @@ +// This file was modified from its original version. +// https://github.com/cosmos/gaia/blob/b3583a755ad2947582f8e9c969806b187668ea23/proto/gaia/liquid/module/v1/module.proto +// Modifications made by KYVE, 2025. + +syntax = "proto3"; + +package kyve.liquid.module.v1; + +import "cosmos/app/v1alpha1/module.proto"; + +// Module is the config object of the liquid module. +message Module { + option (cosmos.app.v1alpha1.module) = { + go_import : "github.com/KYVENetwork/chain/x/liquid" + }; + + // authority defines the custom module authority. If not set, defaults to the + // governance module. + string authority = 1; + + // bech32_prefix_validator is the bech32 validator prefix for the app. + string bech32_prefix_validator = 2; + + // bech32_prefix_consensus is the bech32 consensus node prefix for the app. + string bech32_prefix_consensus = 3; +} diff --git a/proto/kyve/liquid/v1beta1/genesis.proto b/proto/kyve/liquid/v1beta1/genesis.proto new file mode 100644 index 00000000..859ed24d --- /dev/null +++ b/proto/kyve/liquid/v1beta1/genesis.proto @@ -0,0 +1,52 @@ +// This file was modified from its original version. +// https://github.com/cosmos/gaia/blob/b3583a755ad2947582f8e9c969806b187668ea23/proto/gaia/liquid/v1beta1/genesis.proto +// Modifications made by KYVE, 2025. + +syntax = "proto3"; +package kyve.liquid.v1beta1; + +option go_package = "github.com/KYVENetwork/chain/x/liquid/types"; + +import "gogoproto/gogo.proto"; +import "kyve/liquid/v1beta1/liquid.proto"; +import "amino/amino.proto"; +import "google/protobuf/timestamp.proto"; + +// GenesisState defines the liquid module's genesis state. +message GenesisState { + // params defines all the parameters of related to deposit. + Params params = 1 + [ (gogoproto.nullable) = false, (amino.dont_omitempty) = true ]; + + // store tokenize share records to provide reward to record owners + repeated TokenizeShareRecord tokenize_share_records = 9 + [ (gogoproto.nullable) = false ]; + + // last tokenize share record id, used for next share record id calculation + uint64 last_tokenize_share_record_id = 10; + + // total number of liquid staked tokens at genesis + bytes total_liquid_staked_tokens = 11 [ + (gogoproto.customtype) = "cosmossdk.io/math.Int", + (gogoproto.moretags) = "yaml:\"total_liquid_staked_tokens\"", + (gogoproto.nullable) = false + ]; + + // tokenize shares locks at genesis + repeated TokenizeShareLock tokenize_share_locks = 12 + [ (gogoproto.nullable) = false ]; +} + +// TokenizeSharesLock required for specifying account locks at genesis +message TokenizeShareLock { + // Address of the account that is locked + string address = 1; + // Status of the lock (LOCKED or LOCK_EXPIRING) + string status = 2; + // Completion time if the lock is expiring + google.protobuf.Timestamp completion_time = 3 [ + (gogoproto.nullable) = false, + (gogoproto.stdtime) = true, + (gogoproto.moretags) = "yaml:\"completion_time\"" + ]; +} diff --git a/proto/kyve/liquid/v1beta1/liquid.proto b/proto/kyve/liquid/v1beta1/liquid.proto new file mode 100644 index 00000000..034b97ae --- /dev/null +++ b/proto/kyve/liquid/v1beta1/liquid.proto @@ -0,0 +1,102 @@ +// This file was modified from its original version. +// https://github.com/cosmos/gaia/blob/b3583a755ad2947582f8e9c969806b187668ea23/proto/gaia/liquid/v1beta1/liquid.proto +// Modifications made by KYVE, 2025. + +syntax = "proto3"; +package kyve.liquid.v1beta1; + +import "gogoproto/gogo.proto"; + +import "amino/amino.proto"; +import "cosmos/base/v1beta1/coin.proto"; +import "cosmos_proto/cosmos.proto"; + +option go_package = "github.com/KYVENetwork/chain/x/liquid/types"; + +// Params defines the parameters for the x/liquid module. +message Params { + option (amino.name) = "gaia/x/liquid/Params"; + option (gogoproto.equal) = true; + + // global_liquid_staking_cap represents a cap on the portion of stake that + // comes from liquid staking providers + string global_liquid_staking_cap = 8 [ + (gogoproto.moretags) = "yaml:\"global_liquid_staking_cap\"", + (gogoproto.customtype) = "cosmossdk.io/math.LegacyDec", + (gogoproto.nullable) = false, + (amino.dont_omitempty) = true, + (cosmos_proto.scalar) = "cosmos.Dec" + ]; + // validator_liquid_staking_cap represents a cap on the portion of stake that + // comes from liquid staking providers for a specific validator + string validator_liquid_staking_cap = 9 [ + (gogoproto.moretags) = "yaml:\"validator_liquid_staking_cap\"", + (gogoproto.customtype) = "cosmossdk.io/math.LegacyDec", + (gogoproto.nullable) = false, + (amino.dont_omitempty) = true, + (cosmos_proto.scalar) = "cosmos.Dec" + ]; +} + +// TokenizeShareRecord represents a tokenized delegation +message TokenizeShareRecord { + option (gogoproto.equal) = true; + + uint64 id = 1; + string owner = 2; + string module_account = 3; // module account take the role of delegator + string validator = + 4; // validator delegated to for tokenize share record creation +} + +// PendingTokenizeShareAuthorizations stores a list of addresses that have their +// tokenize share enablement in progress +message PendingTokenizeShareAuthorizations { repeated string addresses = 1; } + +// TokenizeShareLockStatus indicates whether the address is able to tokenize +// shares +enum TokenizeShareLockStatus { + option (gogoproto.goproto_enum_prefix) = false; + + // UNSPECIFIED defines an empty tokenize share lock status + TOKENIZE_SHARE_LOCK_STATUS_UNSPECIFIED = 0; + // LOCKED indicates the account is locked and cannot tokenize shares + TOKENIZE_SHARE_LOCK_STATUS_LOCKED = 1; + // UNLOCKED indicates the account is unlocked and can tokenize shares + TOKENIZE_SHARE_LOCK_STATUS_UNLOCKED = 2; + // LOCK_EXPIRING indicates the account is unable to tokenize shares, but + // will be able to tokenize shortly (after 1 unbonding period) + TOKENIZE_SHARE_LOCK_STATUS_LOCK_EXPIRING = 3; +} + +// TokenizeShareRecordReward represents the properties of tokenize share +message TokenizeShareRecordReward { + option (gogoproto.goproto_getters) = false; + option (gogoproto.goproto_stringer) = true; + + uint64 record_id = 1; + + repeated cosmos.base.v1beta1.DecCoin reward = 2 [ + (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.DecCoins", + (gogoproto.nullable) = false + ]; +} + +// LiquidValidator is the storage layout for details about a validator's liquid +// stake. +message LiquidValidator { + option (gogoproto.goproto_getters) = false; + option (gogoproto.goproto_stringer) = true; + + // operator_address defines the address of the validator's operator; bech + // encoded in JSON. + string operator_address = 1 + [ (cosmos_proto.scalar) = "cosmos.AddressString" ]; + + // Number of shares either tokenized or owned by a liquid staking provider + string liquid_shares = 3 [ + (gogoproto.moretags) = "yaml:\"liquid_shares\"", + (gogoproto.customtype) = "cosmossdk.io/math.LegacyDec", + (gogoproto.nullable) = false + ]; +} \ No newline at end of file diff --git a/proto/kyve/liquid/v1beta1/query.proto b/proto/kyve/liquid/v1beta1/query.proto new file mode 100644 index 00000000..7c6527e3 --- /dev/null +++ b/proto/kyve/liquid/v1beta1/query.proto @@ -0,0 +1,246 @@ +// This file was modified from its original version. +// https://github.com/cosmos/gaia/blob/b3583a755ad2947582f8e9c969806b187668ea23/proto/gaia/liquid/v1beta1/query.proto +// Modifications made by KYVE, 2025. + +syntax = "proto3"; +package kyve.liquid.v1beta1; + +import "cosmos/base/query/v1beta1/pagination.proto"; +import "gogoproto/gogo.proto"; +import "google/api/annotations.proto"; +import "kyve/liquid/v1beta1/liquid.proto"; +import "cosmos/base/v1beta1/coin.proto"; +import "cosmos/query/v1/query.proto"; +import "amino/amino.proto"; + +option go_package = "github.com/KYVENetwork/chain/x/liquid/types"; + +// Query defines the gRPC querier service. +service Query { + // LiquidValidators queries all liquid validators. + // + // When called from another module, this query might consume a high amount of + // gas if the pagination field is incorrectly set. + rpc LiquidValidators(QueryLiquidValidatorsRequest) + returns (QueryLiquidValidatorsResponse) { + option (cosmos.query.v1.module_query_safe) = true; + option (google.api.http).get = "/gaia/liquid/v1beta1/liquid_validators"; + } + + // Query for an individual liquid validator by validator address + rpc LiquidValidator(QueryLiquidValidatorRequest) + returns (QueryLiquidValidatorResponse) { + option (google.api.http).get = + "/gaia/liquid/v1beta1/liquid_validator/{validator_addr}"; + } + + // Query for individual tokenize share record information by share by id + rpc TokenizeShareRecordById(QueryTokenizeShareRecordByIdRequest) + returns (QueryTokenizeShareRecordByIdResponse) { + option (google.api.http).get = + "/gaia/liquid/v1beta1/tokenize_share_record_by_id/{id}"; + } + + // Query for individual tokenize share record information by share denom + rpc TokenizeShareRecordByDenom(QueryTokenizeShareRecordByDenomRequest) + returns (QueryTokenizeShareRecordByDenomResponse) { + option (google.api.http).get = + "/gaia/liquid/v1beta1/tokenize_share_record_by_denom/{denom}"; + } + + // Query tokenize share records by address + rpc TokenizeShareRecordsOwned(QueryTokenizeShareRecordsOwnedRequest) + returns (QueryTokenizeShareRecordsOwnedResponse) { + option (google.api.http).get = + "/gaia/liquid/v1beta1/tokenize_share_record_owned/{owner}"; + } + + // Query for all tokenize share records + rpc AllTokenizeShareRecords(QueryAllTokenizeShareRecordsRequest) + returns (QueryAllTokenizeShareRecordsResponse) { + option (google.api.http).get = + "/gaia/liquid/v1beta1/tokenize_share_records"; + } + + // Query for last tokenize share record id + rpc LastTokenizeShareRecordId(QueryLastTokenizeShareRecordIdRequest) + returns (QueryLastTokenizeShareRecordIdResponse) { + option (google.api.http).get = + "/gaia/liquid/v1beta1/last_tokenize_share_record_id"; + } + + // Query for total tokenized staked assets + rpc TotalTokenizeSharedAssets(QueryTotalTokenizeSharedAssetsRequest) + returns (QueryTotalTokenizeSharedAssetsResponse) { + option (google.api.http).get = + "/gaia/liquid/v1beta1/total_tokenize_shared_assets"; + } + + // Query for total liquid staked (including tokenized shares or owned by an + // liquid staking provider) + rpc TotalLiquidStaked(QueryTotalLiquidStaked) + returns (QueryTotalLiquidStakedResponse) { + option (google.api.http).get = "/gaia/liquid/v1beta1/total_liquid_staked"; + } + + // Query tokenize share locks + rpc TokenizeShareLockInfo(QueryTokenizeShareLockInfo) + returns (QueryTokenizeShareLockInfoResponse) { + option (google.api.http).get = + "/gaia/liquid/v1beta1/tokenize_share_lock_info/{address}"; + } + + // Parameters queries the liquid parameters. + rpc Params(QueryParamsRequest) returns (QueryParamsResponse) { + option (cosmos.query.v1.module_query_safe) = true; + option (google.api.http).get = "/gaia/liquid/v1beta1/params"; + } + + // TokenizeShareRecordReward queries the tokenize share record rewards + rpc TokenizeShareRecordReward(QueryTokenizeShareRecordRewardRequest) + returns (QueryTokenizeShareRecordRewardResponse) { + option (google.api.http).get = + "/gaia/liquid/v1beta1/{owner_address}/tokenize_share_record_rewards"; + } +} + +// QueryLiquidValidatorRequest is the request type for the Query/LiquidValidator +// RPC method. +message QueryLiquidValidatorRequest { string validator_addr = 1; } + +// QueryLiquidValidatorResponse is the response type for the +// Query/LiquidValidator RPC method. +message QueryLiquidValidatorResponse { + LiquidValidator liquid_validator = 1 + [ (gogoproto.nullable) = false, (amino.dont_omitempty) = true ]; +} + +// QueryLiquidValidatorsRequest is request type for the +// Query/QueryLiquidValidators RPC method. +message QueryLiquidValidatorsRequest { + // pagination defines an optional pagination for the request. + cosmos.base.query.v1beta1.PageRequest pagination = 1; +} + +// QueryLiquidValidatorsResponse is response type for the +// Query/QueryLiquidValidators RPC method. +message QueryLiquidValidatorsResponse { + repeated LiquidValidator liquid_validators = 1 + [ (gogoproto.nullable) = false, (amino.dont_omitempty) = true ]; + // pagination defines the pagination in the response. + cosmos.base.query.v1beta1.PageResponse pagination = 2; +} + +// QueryParamsRequest is request type for the Query/Params RPC method. +message QueryParamsRequest {} + +// QueryParamsResponse is response type for the Query/Params RPC method. +message QueryParamsResponse { + // params holds all the parameters of this module. + Params params = 1 + [ (gogoproto.nullable) = false, (amino.dont_omitempty) = true ]; +} + +// QueryTokenizeShareRecordByIdRequest is request type for the +// Query/QueryTokenizeShareRecordById RPC method. +message QueryTokenizeShareRecordByIdRequest { uint64 id = 1; } + +// QueryTokenizeShareRecordByIdRequest is response type for the +// Query/QueryTokenizeShareRecordById RPC method. +message QueryTokenizeShareRecordByIdResponse { + TokenizeShareRecord record = 1 [ (gogoproto.nullable) = false ]; +} + +// QueryTokenizeShareRecordByDenomRequest is request type for the +// Query/QueryTokenizeShareRecordByDenom RPC method. +message QueryTokenizeShareRecordByDenomRequest { string denom = 1; } + +// QueryTokenizeShareRecordByDenomResponse is response type for the +// Query/QueryTokenizeShareRecordByDenom RPC method. +message QueryTokenizeShareRecordByDenomResponse { + TokenizeShareRecord record = 1 [ (gogoproto.nullable) = false ]; +} + +// QueryTokenizeShareRecordsOwnedRequest is request type for the +// Query/QueryTokenizeShareRecordsOwned RPC method. +message QueryTokenizeShareRecordsOwnedRequest { string owner = 1; } + +// QueryTokenizeShareRecordsOwnedResponse is response type for the +// Query/QueryTokenizeShareRecordsOwned RPC method. +message QueryTokenizeShareRecordsOwnedResponse { + repeated TokenizeShareRecord records = 1 [ (gogoproto.nullable) = false ]; +} + +// QueryAllTokenizeShareRecordsRequest is request type for the +// Query/QueryAllTokenizeShareRecords RPC method. +message QueryAllTokenizeShareRecordsRequest { + // pagination defines an optional pagination for the request. + cosmos.base.query.v1beta1.PageRequest pagination = 1; +} + +// QueryAllTokenizeShareRecordsResponse is response type for the +// Query/QueryAllTokenizeShareRecords RPC method. +message QueryAllTokenizeShareRecordsResponse { + repeated TokenizeShareRecord records = 1 [ (gogoproto.nullable) = false ]; + // pagination defines the pagination in the response. + cosmos.base.query.v1beta1.PageResponse pagination = 2; +} + +// QueryLastTokenizeShareRecordIdRequest is request type for the +// Query/QueryLastTokenizeShareRecordId RPC method. +message QueryLastTokenizeShareRecordIdRequest {} + +// QueryLastTokenizeShareRecordIdResponse is response type for the +// Query/QueryLastTokenizeShareRecordId RPC method. +message QueryLastTokenizeShareRecordIdResponse { uint64 id = 1; } + +// QueryTotalTokenizeSharedAssetsRequest is request type for the +// Query/QueryTotalTokenizeSharedAssets RPC method. +message QueryTotalTokenizeSharedAssetsRequest {} + +// QueryTotalTokenizeSharedAssetsResponse is response type for the +// Query/QueryTotalTokenizeSharedAssets RPC method. +message QueryTotalTokenizeSharedAssetsResponse { + cosmos.base.v1beta1.Coin value = 1 [ (gogoproto.nullable) = false ]; +} + +// QueryTotalLiquidStakedRequest is request type for the +// Query/QueryQueryTotalLiquidStaked RPC method. +message QueryTotalLiquidStaked {} + +// QueryTotalLiquidStakedResponse is response type for the +// Query/QueryQueryTotalLiquidStaked RPC method. +message QueryTotalLiquidStakedResponse { string tokens = 1; } + +// QueryTokenizeShareLockInfo queries the tokenize share lock information +// associated with given account +message QueryTokenizeShareLockInfo { string address = 1; } + +// QueryTokenizeShareLockInfoResponse is the response from the +// QueryTokenizeShareLockInfo query +message QueryTokenizeShareLockInfoResponse { + string status = 1; + string expiration_time = 2; +} + +// QueryTokenizeShareRecordRewardRequest is the request type for the +// Query/TokenizeShareRecordReward RPC method. +message QueryTokenizeShareRecordRewardRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string owner_address = 1 [ (gogoproto.moretags) = "yaml:\"owner_address\"" ]; +} + +// QueryTokenizeShareRecordRewardResponse is the response type for the +// Query/TokenizeShareRecordReward RPC method. +message QueryTokenizeShareRecordRewardResponse { + // rewards defines all the rewards accrued by a delegator. + repeated TokenizeShareRecordReward rewards = 1 + [ (gogoproto.nullable) = false ]; + // total defines the sum of all the rewards. + repeated cosmos.base.v1beta1.DecCoin total = 2 [ + (gogoproto.nullable) = false, + (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.DecCoins" + ]; +} \ No newline at end of file diff --git a/proto/kyve/liquid/v1beta1/tx.proto b/proto/kyve/liquid/v1beta1/tx.proto new file mode 100644 index 00000000..a107598b --- /dev/null +++ b/proto/kyve/liquid/v1beta1/tx.proto @@ -0,0 +1,206 @@ +// This file was modified from its original version. +// https://github.com/cosmos/gaia/blob/b3583a755ad2947582f8e9c969806b187668ea23/proto/gaia/liquid/v1beta1/tx.proto +// Modifications made by KYVE, 2025. + +syntax = "proto3"; +package kyve.liquid.v1beta1; + +import "google/protobuf/timestamp.proto"; +import "gogoproto/gogo.proto"; + +import "cosmos_proto/cosmos.proto"; +import "cosmos/base/v1beta1/coin.proto"; +import "kyve/liquid/v1beta1/liquid.proto"; +import "cosmos/msg/v1/msg.proto"; +import "amino/amino.proto"; + +option go_package = "github.com/KYVENetwork/chain/x/liquid/types"; + +// Msg defines the liquid Msg service. +service Msg { + option (cosmos.msg.v1.service) = true; + + // UpdateParams defines an operation for updating the x/liquid module + // parameters. + rpc UpdateParams(MsgUpdateParams) returns (MsgUpdateParamsResponse); + + // TokenizeShares defines a method for tokenizing shares from a validator. + rpc TokenizeShares(MsgTokenizeShares) returns (MsgTokenizeSharesResponse); + + // RedeemTokensForShares defines a method for redeeming tokens from a + // validator for shares. + rpc RedeemTokensForShares(MsgRedeemTokensForShares) + returns (MsgRedeemTokensForSharesResponse); + + // TransferTokenizeShareRecord defines a method to transfer ownership of + // TokenizeShareRecord + rpc TransferTokenizeShareRecord(MsgTransferTokenizeShareRecord) + returns (MsgTransferTokenizeShareRecordResponse); + + // DisableTokenizeShares defines a method to prevent the tokenization of an + // addresses stake + rpc DisableTokenizeShares(MsgDisableTokenizeShares) + returns (MsgDisableTokenizeSharesResponse); + + // EnableTokenizeShares defines a method to re-enable the tokenization of an + // addresseses stake after it has been disabled + rpc EnableTokenizeShares(MsgEnableTokenizeShares) + returns (MsgEnableTokenizeSharesResponse); + + // WithdrawTokenizeShareRecordReward defines a method to withdraw reward for + // an owning TokenizeShareRecord + rpc WithdrawTokenizeShareRecordReward(MsgWithdrawTokenizeShareRecordReward) + returns (MsgWithdrawTokenizeShareRecordRewardResponse); + + // WithdrawAllTokenizeShareRecordReward defines a method to withdraw reward + // for all owning TokenizeShareRecord + rpc WithdrawAllTokenizeShareRecordReward( + MsgWithdrawAllTokenizeShareRecordReward) + returns (MsgWithdrawAllTokenizeShareRecordRewardResponse); +} + +// MsgUpdateParams is the Msg/UpdateParams request type. +message MsgUpdateParams { + option (cosmos.msg.v1.signer) = "authority"; + option (amino.name) = "gaia/liquid/MsgUpdateParams"; + + // authority is the address that controls the module (defaults to x/gov unless + // overwritten). + string authority = 1 [ (cosmos_proto.scalar) = "cosmos.AddressString" ]; + // params defines the x/liquid parameters to update. + // + // NOTE: All parameters must be supplied. + Params params = 2 + [ (gogoproto.nullable) = false, (amino.dont_omitempty) = true ]; +}; + +// MsgUpdateParamsResponse defines the response structure for executing a +// MsgUpdateParams message. +message MsgUpdateParamsResponse {}; + +// MsgTokenizeShares tokenizes a delegation +message MsgTokenizeShares { + option (cosmos.msg.v1.signer) = "delegator_address"; + option (amino.name) = "gaia/MsgTokenizeShares"; + + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string delegator_address = 1 + [ (gogoproto.moretags) = "yaml:\"delegator_address\"" ]; + string validator_address = 2 + [ (gogoproto.moretags) = "yaml:\"validator_address\"" ]; + cosmos.base.v1beta1.Coin amount = 3 [ (gogoproto.nullable) = false ]; + string tokenized_share_owner = 4; +} + +// MsgTokenizeSharesResponse defines the Msg/MsgTokenizeShares response type. +message MsgTokenizeSharesResponse { + cosmos.base.v1beta1.Coin amount = 1 [ (gogoproto.nullable) = false ]; +} + +// MsgRedeemTokensForShares redeems a tokenized share back into a native +// delegation +message MsgRedeemTokensForShares { + option (cosmos.msg.v1.signer) = "delegator_address"; + option (amino.name) = "gaia/MsgRedeemTokensForShares"; + + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string delegator_address = 1 + [ (gogoproto.moretags) = "yaml:\"delegator_address\"" ]; + cosmos.base.v1beta1.Coin amount = 2 [ (gogoproto.nullable) = false ]; +} + +// MsgRedeemTokensForSharesResponse defines the Msg/MsgRedeemTokensForShares +// response type. +message MsgRedeemTokensForSharesResponse { + cosmos.base.v1beta1.Coin amount = 1 [ (gogoproto.nullable) = false ]; +} + +// MsgTransferTokenizeShareRecord transfer a tokenize share record +message MsgTransferTokenizeShareRecord { + option (cosmos.msg.v1.signer) = "sender"; + option (amino.name) = "gaia/MsgTransferTokenizeShareRecord"; + + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + uint64 tokenize_share_record_id = 1; + string sender = 2; + string new_owner = 3; +} + +// MsgTransferTokenizeShareRecordResponse defines the +// Msg/MsgTransferTokenizeShareRecord response type. +message MsgTransferTokenizeShareRecordResponse {} + +// MsgDisableTokenizeShares prevents the tokenization of shares for a given +// address +message MsgDisableTokenizeShares { + option (cosmos.msg.v1.signer) = "delegator_address"; + option (amino.name) = "gaia/MsgDisableTokenizeShares"; + + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string delegator_address = 1 + [ (gogoproto.moretags) = "yaml:\"delegator_address\"" ]; +} + +// MsgDisableTokenizeSharesResponse defines the Msg/DisableTokenizeShares +// response type. +message MsgDisableTokenizeSharesResponse {} + +// MsgEnableTokenizeShares re-enables tokenization of shares for a given address +message MsgEnableTokenizeShares { + option (cosmos.msg.v1.signer) = "delegator_address"; + option (amino.name) = "gaia/MsgEnableTokenizeShares"; + + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string delegator_address = 1 + [ (gogoproto.moretags) = "yaml:\"delegator_address\"" ]; +} + +// MsgEnableTokenizeSharesResponse defines the Msg/EnableTokenizeShares response +// type. +message MsgEnableTokenizeSharesResponse { + google.protobuf.Timestamp completion_time = 1 + [ (gogoproto.nullable) = false, (gogoproto.stdtime) = true ]; +} + +// MsgWithdrawTokenizeShareRecordReward withdraws tokenize share rewards for a +// specific record +message MsgWithdrawTokenizeShareRecordReward { + option (cosmos.msg.v1.signer) = "owner_address"; + option (amino.name) = "gaia/MsgWithdrawTokenizeShareRecordReward"; + + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string owner_address = 1 [ (gogoproto.moretags) = "yaml:\"owner_address\"" ]; + uint64 record_id = 2; +} + +// MsgWithdrawTokenizeShareRecordReward defines the +// Msg/WithdrawTokenizeShareRecordReward response type. +message MsgWithdrawTokenizeShareRecordRewardResponse {} + +// MsgWithdrawAllTokenizeShareRecordReward withdraws tokenize share rewards or +// all records owned by the designated owner +message MsgWithdrawAllTokenizeShareRecordReward { + option (cosmos.msg.v1.signer) = "owner_address"; + option (amino.name) = "gaia/MsgWithdrawAllTokenizeShareRecordReward"; + + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string owner_address = 1 [ (gogoproto.moretags) = "yaml:\"owner_address\"" ]; +} + +// MsgWithdrawAllTokenizeShareRecordRewardResponse defines the +// Msg/WithdrawTokenizeShareRecordReward response type. +message MsgWithdrawAllTokenizeShareRecordRewardResponse {} diff --git a/x/liquid/autocli.go b/x/liquid/autocli.go index 43c05f5e..dc648049 100644 --- a/x/liquid/autocli.go +++ b/x/liquid/autocli.go @@ -1,3 +1,8 @@ +// This file was modified from its original version. +// https://github.com/cosmos/gaia/blob/b3583a755ad2947582f8e9c969806b187668ea23/x/liquid/autocli.go +// Modifications made by KYVE, 2025. +// - Changed import paths + package liquid import ( diff --git a/x/liquid/client/cli/tx.go b/x/liquid/client/cli/tx.go index c1040fcc..99bd72db 100644 --- a/x/liquid/client/cli/tx.go +++ b/x/liquid/client/cli/tx.go @@ -1,3 +1,8 @@ +// This file was modified from its original version. +// Original source: https://github.com/cosmos/gaia/blob/b3583a755ad2947582f8e9c969806b187668ea23/x/liquid/client/cli/tx.go +// Modifications made by KYVE, 2025. +// - Changed import paths + package cli import ( diff --git a/x/liquid/keeper/distribution.go b/x/liquid/keeper/distribution.go index d9c2505d..287e1919 100644 --- a/x/liquid/keeper/distribution.go +++ b/x/liquid/keeper/distribution.go @@ -1,3 +1,8 @@ +// This file was modified from its original version. +// https://github.com/cosmos/gaia/blob/b3583a755ad2947582f8e9c969806b187668ea23/x/liquid/keeper/distribution.go +// Modifications made by KYVE, 2025. +// - Changed import paths + package keeper import ( diff --git a/x/liquid/keeper/genesis.go b/x/liquid/keeper/genesis.go index b351d64c..22ff40f0 100644 --- a/x/liquid/keeper/genesis.go +++ b/x/liquid/keeper/genesis.go @@ -1,3 +1,8 @@ +// This file was modified from its original version. +// https://github.com/cosmos/gaia/blob/b3583a755ad2947582f8e9c969806b187668ea23/x/liquid/keeper/genesis.go +// Modifications made by KYVE, 2025. +// - Changed import paths + package keeper import ( diff --git a/x/liquid/keeper/grpc_query.go b/x/liquid/keeper/grpc_query.go index caf18747..6e0dfc4a 100644 --- a/x/liquid/keeper/grpc_query.go +++ b/x/liquid/keeper/grpc_query.go @@ -1,3 +1,8 @@ +// This file was modified from its original version. +// https://github.com/cosmos/gaia/blob/b3583a755ad2947582f8e9c969806b187668ea23/x/liquid/keeper/grpc_query.go +// Modifications made by KYVE, 2025. +// - Changed import paths + package keeper import ( diff --git a/x/liquid/keeper/grpc_query_test.go b/x/liquid/keeper/grpc_query_test.go index 6473f924..0da3d9f5 100644 --- a/x/liquid/keeper/grpc_query_test.go +++ b/x/liquid/keeper/grpc_query_test.go @@ -1,3 +1,8 @@ +// This file was modified from its original version. +// https://github.com/cosmos/gaia/blob/b3583a755ad2947582f8e9c969806b187668ea23/x/liquid/keeper/grpc_query_test.go +// Modifications made by KYVE, 2025. +// - Changed import paths + package keeper_test import ( diff --git a/x/liquid/keeper/hooks.go b/x/liquid/keeper/hooks.go index 31f2bde6..b2fdcae8 100644 --- a/x/liquid/keeper/hooks.go +++ b/x/liquid/keeper/hooks.go @@ -1,3 +1,8 @@ +// This file was modified from its original version. +// https://github.com/cosmos/gaia/blob/b3583a755ad2947582f8e9c969806b187668ea23/x/liquid/keeper/hooks.go +// Modifications made by KYVE, 2025. +// - Changed import paths + package keeper import ( diff --git a/x/liquid/keeper/keeper.go b/x/liquid/keeper/keeper.go index 20dddee1..9d846be6 100644 --- a/x/liquid/keeper/keeper.go +++ b/x/liquid/keeper/keeper.go @@ -1,3 +1,8 @@ +// This file was modified from its original version. +// https://github.com/cosmos/gaia/blob/b3583a755ad2947582f8e9c969806b187668ea23/x/liquid/keeper/keeper.go +// Modifications made by KYVE, 2025. +// - Changed import paths + package keeper import ( diff --git a/x/liquid/keeper/keeper_test.go b/x/liquid/keeper/keeper_test.go index 087a202f..388900db 100644 --- a/x/liquid/keeper/keeper_test.go +++ b/x/liquid/keeper/keeper_test.go @@ -1,3 +1,8 @@ +// This file was modified from its original version. +// https://github.com/cosmos/gaia/blob/b3583a755ad2947582f8e9c969806b187668ea23/x/liquid/keeper/keeper_test.go +// Modifications made by KYVE, 2025. +// - Changed import paths + package keeper_test import ( diff --git a/x/liquid/keeper/liquid_stake.go b/x/liquid/keeper/liquid_stake.go index 37b9ab0a..a830b7e2 100644 --- a/x/liquid/keeper/liquid_stake.go +++ b/x/liquid/keeper/liquid_stake.go @@ -1,3 +1,8 @@ +// This file was modified from its original version. +// https://github.com/cosmos/gaia/blob/b3583a755ad2947582f8e9c969806b187668ea23/x/liquid/keeper/liquid_stake.go +// Modifications made by KYVE, 2025. +// - Changed import paths + package keeper import ( diff --git a/x/liquid/keeper/liquid_stake_test.go b/x/liquid/keeper/liquid_stake_test.go index 91c445c8..548bf0e7 100644 --- a/x/liquid/keeper/liquid_stake_test.go +++ b/x/liquid/keeper/liquid_stake_test.go @@ -1,3 +1,8 @@ +// This file was modified from its original version. +// https://github.com/cosmos/gaia/blob/b3583a755ad2947582f8e9c969806b187668ea23/x/liquid/keeper/liquid_stake_test.go +// Modifications made by KYVE, 2025. +// - Changed import paths + package keeper_test import ( diff --git a/x/liquid/keeper/msg_server.go b/x/liquid/keeper/msg_server.go index ebe7352b..16b2638f 100644 --- a/x/liquid/keeper/msg_server.go +++ b/x/liquid/keeper/msg_server.go @@ -1,3 +1,8 @@ +// This file was modified from its original version. +// https://github.com/cosmos/gaia/blob/b3583a755ad2947582f8e9c969806b187668ea23/x/liquid/keeper/msg_server.go +// Modifications made by KYVE, 2025. +// - Changed import paths + package keeper import ( diff --git a/x/liquid/keeper/params.go b/x/liquid/keeper/params.go index 44f82004..b8d9f485 100644 --- a/x/liquid/keeper/params.go +++ b/x/liquid/keeper/params.go @@ -1,3 +1,8 @@ +// This file was modified from its original version. +// https://github.com/cosmos/gaia/blob/b3583a755ad2947582f8e9c969806b187668ea23/x/liquid/keeper/params.go +// Modifications made by KYVE, 2025. +// - Changed import paths + package keeper import ( diff --git a/x/liquid/keeper/tokenize_share_record.go b/x/liquid/keeper/tokenize_share_record.go index 974f0c53..744a6622 100644 --- a/x/liquid/keeper/tokenize_share_record.go +++ b/x/liquid/keeper/tokenize_share_record.go @@ -1,3 +1,8 @@ +// This file was modified from its original version. +// https://github.com/cosmos/gaia/blob/b3583a755ad2947582f8e9c969806b187668ea23/x/liquid/keeper/tokenize_share_record.go +// Modifications made by KYVE, 2025. +// - Changed import paths + package keeper import ( diff --git a/x/liquid/keeper/tokenize_share_record_test.go b/x/liquid/keeper/tokenize_share_record_test.go index e63dd18a..7eb9c8bc 100644 --- a/x/liquid/keeper/tokenize_share_record_test.go +++ b/x/liquid/keeper/tokenize_share_record_test.go @@ -1,3 +1,8 @@ +// This file was modified from its original version. +// https://github.com/cosmos/gaia/blob/b3583a755ad2947582f8e9c969806b187668ea23/x/liquid/keeper/tokenize_share_record_test.go +// Modifications made by KYVE, 2025. +// - Changed import paths + package keeper_test import ( diff --git a/x/liquid/module.go b/x/liquid/module.go index 8136537b..0194d459 100644 --- a/x/liquid/module.go +++ b/x/liquid/module.go @@ -1,3 +1,7 @@ +// This file was modified from its original version. +// https://github.com/cosmos/gaia/blob/b3583a755ad2947582f8e9c969806b187668ea23/x/liquid/module.go +// Modifications made by KYVE, 2025. + package liquid import ( diff --git a/x/liquid/types/genesis.pb.go b/x/liquid/types/genesis.pb.go index b3e20ac7..4c509112 100644 --- a/x/liquid/types/genesis.pb.go +++ b/x/liquid/types/genesis.pb.go @@ -1,5 +1,5 @@ // Code generated by protoc-gen-gogo. DO NOT EDIT. -// source: kyve/liquid/v1beta1/genesis.proto +// source: gaia/liquid/v1beta1/genesis.proto package types @@ -47,7 +47,7 @@ func (m *GenesisState) Reset() { *m = GenesisState{} } func (m *GenesisState) String() string { return proto.CompactTextString(m) } func (*GenesisState) ProtoMessage() {} func (*GenesisState) Descriptor() ([]byte, []int) { - return fileDescriptor_1e0ff895af275f9d, []int{0} + return fileDescriptor_492f6dcc93442fc6, []int{0} } func (m *GenesisState) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -118,7 +118,7 @@ func (m *TokenizeShareLock) Reset() { *m = TokenizeShareLock{} } func (m *TokenizeShareLock) String() string { return proto.CompactTextString(m) } func (*TokenizeShareLock) ProtoMessage() {} func (*TokenizeShareLock) Descriptor() ([]byte, []int) { - return fileDescriptor_1e0ff895af275f9d, []int{1} + return fileDescriptor_492f6dcc93442fc6, []int{1} } func (m *TokenizeShareLock) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -169,47 +169,46 @@ func (m *TokenizeShareLock) GetCompletionTime() time.Time { } func init() { - proto.RegisterType((*GenesisState)(nil), "kyve.liquid.v1beta1.GenesisState") - proto.RegisterType((*TokenizeShareLock)(nil), "kyve.liquid.v1beta1.TokenizeShareLock") -} - -func init() { proto.RegisterFile("kyve/liquid/v1beta1/genesis.proto", fileDescriptor_1e0ff895af275f9d) } - -var fileDescriptor_1e0ff895af275f9d = []byte{ - // 518 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x53, 0x4d, 0x8b, 0xd3, 0x40, - 0x18, 0x6e, 0xdc, 0xa5, 0xd2, 0x69, 0x51, 0x36, 0xd6, 0x1a, 0x2b, 0x26, 0xdd, 0x1c, 0xa4, 0x28, - 0xcc, 0xb0, 0xeb, 0xcd, 0x83, 0x48, 0x60, 0x91, 0xc5, 0x45, 0x24, 0x5d, 0x04, 0x3d, 0x18, 0xa6, - 0xc9, 0x98, 0x0e, 0xf9, 0x98, 0x9a, 0x79, 0xbb, 0x5a, 0x2f, 0xfe, 0x85, 0xfd, 0x19, 0x9e, 0xc4, - 0x9f, 0xb1, 0xc7, 0xbd, 0x29, 0x1e, 0xaa, 0xb4, 0x07, 0xef, 0xfb, 0x0b, 0x24, 0x33, 0x29, 0x42, - 0x37, 0xe2, 0x25, 0xe4, 0x9d, 0xe7, 0x23, 0x0f, 0x6f, 0x9e, 0x41, 0xbb, 0xc9, 0xfc, 0x84, 0x91, - 0x94, 0xbf, 0x9b, 0xf1, 0x88, 0x9c, 0xec, 0x8d, 0x19, 0xd0, 0x3d, 0x12, 0xb3, 0x9c, 0x49, 0x2e, - 0xf1, 0xb4, 0x10, 0x20, 0xcc, 0x1b, 0x25, 0x05, 0x6b, 0x0a, 0xae, 0x28, 0xfd, 0x6e, 0x2c, 0x62, - 0xa1, 0x70, 0x52, 0xbe, 0x69, 0x6a, 0x7f, 0x50, 0xe7, 0x56, 0x29, 0x35, 0x63, 0x87, 0x66, 0x3c, - 0x17, 0x44, 0x3d, 0xab, 0x23, 0x27, 0x16, 0x22, 0x4e, 0x19, 0x51, 0xd3, 0x78, 0xf6, 0x96, 0x00, - 0xcf, 0x98, 0x04, 0x9a, 0x4d, 0x35, 0xc1, 0xfd, 0xb6, 0x85, 0x3a, 0x4f, 0x75, 0xa4, 0x11, 0x50, - 0x60, 0xe6, 0x63, 0xd4, 0x9c, 0xd2, 0x82, 0x66, 0xd2, 0x32, 0x06, 0xc6, 0xb0, 0xbd, 0x7f, 0x07, - 0xd7, 0x44, 0xc4, 0x2f, 0x14, 0xc5, 0x6b, 0x9d, 0x2d, 0x9c, 0xc6, 0xe7, 0xdf, 0x5f, 0xef, 0x1b, - 0x7e, 0xa5, 0x32, 0x23, 0xd4, 0x03, 0x91, 0xb0, 0x9c, 0x7f, 0x64, 0x81, 0x9c, 0xd0, 0x82, 0x05, - 0x05, 0x0b, 0x45, 0x11, 0x49, 0xab, 0x35, 0xd8, 0x1a, 0xb6, 0xf7, 0x87, 0xb5, 0x7e, 0xc7, 0x95, - 0x64, 0x54, 0x2a, 0x7c, 0x25, 0xf0, 0xb6, 0x4b, 0x73, 0xbf, 0x0b, 0x97, 0x21, 0x69, 0x3e, 0x41, - 0x77, 0x53, 0x2a, 0x21, 0xa8, 0xfd, 0x54, 0xc0, 0x23, 0x0b, 0x0d, 0x8c, 0xe1, 0xb6, 0x7f, 0xbb, - 0x24, 0xd5, 0x78, 0x1f, 0x46, 0xe6, 0x27, 0xd4, 0x07, 0x01, 0x34, 0x0d, 0x74, 0x92, 0x40, 0x02, - 0x4d, 0x58, 0xa4, 0x0d, 0xa5, 0xd5, 0x1e, 0x18, 0xc3, 0x8e, 0xe7, 0x95, 0x09, 0x7e, 0x2c, 0x9c, - 0x9b, 0xa1, 0x90, 0x99, 0x90, 0x32, 0x4a, 0x30, 0x17, 0x24, 0xa3, 0x30, 0xc1, 0x87, 0x39, 0x5c, - 0x2c, 0x9c, 0xdd, 0x39, 0xcd, 0xd2, 0x47, 0xee, 0xbf, 0x8d, 0x5c, 0xff, 0x96, 0x02, 0x8f, 0x14, - 0x36, 0x52, 0x90, 0xca, 0x23, 0xcd, 0x37, 0xa8, 0xbb, 0x91, 0x3e, 0x15, 0x61, 0x22, 0xad, 0x8e, - 0x5a, 0xd3, 0xbd, 0xff, 0xaf, 0xe9, 0x48, 0x84, 0x49, 0xb5, 0x24, 0x13, 0x36, 0x01, 0xe9, 0x7e, - 0x31, 0xd0, 0xce, 0x25, 0xbe, 0x69, 0xa1, 0xab, 0x34, 0x8a, 0x0a, 0x26, 0xf5, 0xff, 0x6d, 0xf9, - 0xeb, 0xd1, 0xec, 0xa1, 0xa6, 0x04, 0x0a, 0x33, 0x69, 0x5d, 0x51, 0x40, 0x35, 0x99, 0x31, 0xba, - 0x1e, 0x8a, 0x6c, 0x9a, 0x32, 0xe0, 0x22, 0x0f, 0xca, 0xfe, 0x58, 0x5b, 0xaa, 0x19, 0x7d, 0xac, - 0xcb, 0x85, 0xd7, 0xe5, 0xc2, 0xc7, 0xeb, 0x72, 0x79, 0x6e, 0x19, 0xeb, 0x62, 0xe1, 0xf4, 0xf4, - 0x82, 0x36, 0x0c, 0xdc, 0xd3, 0x9f, 0x8e, 0xe1, 0x5f, 0xfb, 0x7b, 0x5a, 0x0a, 0xbd, 0x83, 0xb3, - 0xa5, 0x6d, 0x9c, 0x2f, 0x6d, 0xe3, 0xd7, 0xd2, 0x36, 0x4e, 0x57, 0x76, 0xe3, 0x7c, 0x65, 0x37, - 0xbe, 0xaf, 0xec, 0xc6, 0xeb, 0x07, 0x31, 0x87, 0xc9, 0x6c, 0x8c, 0x43, 0x91, 0x91, 0x67, 0xaf, - 0x5e, 0x1e, 0x3c, 0x67, 0xf0, 0x5e, 0x14, 0x09, 0x09, 0x27, 0x94, 0xe7, 0xe4, 0xc3, 0xfa, 0x52, - 0xc0, 0x7c, 0xca, 0xe4, 0xb8, 0xa9, 0xe2, 0x3c, 0xfc, 0x13, 0x00, 0x00, 0xff, 0xff, 0xba, 0x94, - 0x18, 0xc6, 0x7e, 0x03, 0x00, 0x00, + proto.RegisterType((*GenesisState)(nil), "gaia.liquid.v1beta1.GenesisState") + proto.RegisterType((*TokenizeShareLock)(nil), "gaia.liquid.v1beta1.TokenizeShareLock") +} + +func init() { proto.RegisterFile("gaia/liquid/v1beta1/genesis.proto", fileDescriptor_492f6dcc93442fc6) } + +var fileDescriptor_492f6dcc93442fc6 = []byte{ + // 508 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x53, 0x3f, 0x6f, 0xd3, 0x4e, + 0x18, 0x8e, 0x7f, 0xa9, 0xf2, 0x53, 0x2e, 0x11, 0xa8, 0x26, 0x04, 0x13, 0x84, 0x9d, 0x5a, 0x02, + 0x45, 0x0c, 0x77, 0x6a, 0xd9, 0x18, 0x00, 0x79, 0x41, 0x95, 0x3a, 0x20, 0xa7, 0x13, 0x03, 0xd6, + 0xc5, 0x3e, 0x9c, 0x53, 0xec, 0x5c, 0xf0, 0xfb, 0x06, 0x51, 0x16, 0xbe, 0x42, 0x3f, 0x06, 0x13, + 0xe2, 0x63, 0x74, 0xec, 0x06, 0x62, 0x08, 0x28, 0x19, 0xd8, 0xfb, 0x09, 0x90, 0xef, 0x1c, 0x21, + 0xa5, 0x46, 0x2c, 0x51, 0xde, 0x7b, 0xfe, 0xf8, 0xd1, 0x7b, 0xcf, 0x91, 0x83, 0x94, 0x4b, 0xce, + 0x32, 0xf9, 0x76, 0x29, 0x13, 0xf6, 0xee, 0x70, 0x22, 0x90, 0x1f, 0xb2, 0x54, 0xcc, 0x05, 0x48, + 0xa0, 0x8b, 0x42, 0xa1, 0xb2, 0x6f, 0x95, 0x14, 0x6a, 0x28, 0xb4, 0xa2, 0x0c, 0x7a, 0xa9, 0x4a, + 0x95, 0xc6, 0x59, 0xf9, 0xcf, 0x50, 0x07, 0xc3, 0x3a, 0xb7, 0x4a, 0x69, 0x18, 0xfb, 0x3c, 0x97, + 0x73, 0xc5, 0xf4, 0x6f, 0x75, 0xe4, 0xa5, 0x4a, 0xa5, 0x99, 0x60, 0x7a, 0x9a, 0x2c, 0xdf, 0x30, + 0x94, 0xb9, 0x00, 0xe4, 0xf9, 0xc2, 0x10, 0xfc, 0xaf, 0x4d, 0xd2, 0x7d, 0x61, 0x22, 0x8d, 0x91, + 0xa3, 0xb0, 0x9f, 0x92, 0xd6, 0x82, 0x17, 0x3c, 0x07, 0xc7, 0x1a, 0x5a, 0xa3, 0xce, 0xd1, 0x3d, + 0x5a, 0x13, 0x91, 0xbe, 0xd4, 0x94, 0xa0, 0x7d, 0xb1, 0xf2, 0x1a, 0x9f, 0x7e, 0x7d, 0x79, 0x64, + 0x85, 0x95, 0xca, 0x4e, 0x48, 0x1f, 0xd5, 0x4c, 0xcc, 0xe5, 0x07, 0x11, 0xc1, 0x94, 0x17, 0x22, + 0x2a, 0x44, 0xac, 0x8a, 0x04, 0x9c, 0xf6, 0xb0, 0x39, 0xea, 0x1c, 0x8d, 0x6a, 0xfd, 0x4e, 0x2b, + 0xc9, 0xb8, 0x54, 0x84, 0x5a, 0x10, 0xec, 0x95, 0xe6, 0x61, 0x0f, 0xaf, 0x43, 0x60, 0x3f, 0x27, + 0xf7, 0x33, 0x0e, 0x18, 0xd5, 0x7e, 0x2a, 0x92, 0x89, 0x43, 0x86, 0xd6, 0x68, 0x2f, 0xbc, 0x5b, + 0x92, 0x6a, 0xbc, 0x8f, 0x13, 0xfb, 0x23, 0x19, 0xa0, 0x42, 0x9e, 0x45, 0x26, 0x49, 0x04, 0xc8, + 0x67, 0x22, 0x31, 0x86, 0xe0, 0x74, 0x86, 0xd6, 0xa8, 0x1b, 0x04, 0x65, 0x82, 0xef, 0x2b, 0xef, + 0x76, 0xac, 0x20, 0x57, 0x00, 0xc9, 0x8c, 0x4a, 0xc5, 0x72, 0x8e, 0x53, 0x7a, 0x3c, 0xc7, 0xab, + 0x95, 0x77, 0x70, 0xc6, 0xf3, 0xec, 0x89, 0xff, 0x77, 0x23, 0x3f, 0xbc, 0xa3, 0xc1, 0x13, 0x8d, + 0x8d, 0x35, 0xa4, 0xf3, 0x80, 0xfd, 0x9a, 0xf4, 0x76, 0xd2, 0x67, 0x2a, 0x9e, 0x81, 0xd3, 0xd5, + 0x6b, 0x7a, 0xf8, 0xef, 0x35, 0x9d, 0xa8, 0x78, 0x56, 0x2d, 0xc9, 0xc6, 0x5d, 0x00, 0xfc, 0xcf, + 0x16, 0xd9, 0xbf, 0xc6, 0xb7, 0x1d, 0xf2, 0x3f, 0x4f, 0x92, 0x42, 0x80, 0xb9, 0xdf, 0x76, 0xb8, + 0x1d, 0xed, 0x3e, 0x69, 0x01, 0x72, 0x5c, 0x82, 0xf3, 0x9f, 0x06, 0xaa, 0xc9, 0x4e, 0xc9, 0xcd, + 0x58, 0xe5, 0x8b, 0x4c, 0xa0, 0x54, 0xf3, 0xa8, 0xec, 0x8f, 0xd3, 0xd4, 0xcd, 0x18, 0x50, 0x53, + 0x2e, 0xba, 0x2d, 0x17, 0x3d, 0xdd, 0x96, 0x2b, 0xf0, 0xcb, 0x58, 0x57, 0x2b, 0xaf, 0x6f, 0x16, + 0xb4, 0x63, 0xe0, 0x9f, 0xff, 0xf0, 0xac, 0xf0, 0xc6, 0x9f, 0xd3, 0x52, 0x18, 0x3c, 0xbb, 0x58, + 0xbb, 0xd6, 0xe5, 0xda, 0xb5, 0x7e, 0xae, 0x5d, 0xeb, 0x7c, 0xe3, 0x36, 0x2e, 0x37, 0x6e, 0xe3, + 0xdb, 0xc6, 0x6d, 0xbc, 0x7a, 0x90, 0x4a, 0x9c, 0x2e, 0x27, 0x34, 0x56, 0x39, 0x33, 0x57, 0xc1, + 0xf4, 0x63, 0x78, 0xbf, 0x7d, 0x0e, 0x78, 0xb6, 0x10, 0x30, 0x69, 0xe9, 0x20, 0x8f, 0x7f, 0x07, + 0x00, 0x00, 0xff, 0xff, 0x55, 0xb5, 0xaf, 0x8a, 0x78, 0x03, 0x00, 0x00, } func (m *GenesisState) Marshal() (dAtA []byte, err error) { diff --git a/x/liquid/types/liquid.pb.go b/x/liquid/types/liquid.pb.go index 2bfdec09..56825005 100644 --- a/x/liquid/types/liquid.pb.go +++ b/x/liquid/types/liquid.pb.go @@ -1,5 +1,5 @@ // Code generated by protoc-gen-gogo. DO NOT EDIT. -// source: kyve/liquid/v1beta1/liquid.proto +// source: gaia/liquid/v1beta1/liquid.proto package types @@ -63,7 +63,7 @@ func (x TokenizeShareLockStatus) String() string { } func (TokenizeShareLockStatus) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_83fe2aa3458e6a34, []int{0} + return fileDescriptor_7b1e248decf35ce8, []int{0} } // Params defines the parameters for the x/liquid module. @@ -80,7 +80,7 @@ func (m *Params) Reset() { *m = Params{} } func (m *Params) String() string { return proto.CompactTextString(m) } func (*Params) ProtoMessage() {} func (*Params) Descriptor() ([]byte, []int) { - return fileDescriptor_83fe2aa3458e6a34, []int{0} + return fileDescriptor_7b1e248decf35ce8, []int{0} } func (m *Params) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -121,7 +121,7 @@ func (m *TokenizeShareRecord) Reset() { *m = TokenizeShareRecord{} } func (m *TokenizeShareRecord) String() string { return proto.CompactTextString(m) } func (*TokenizeShareRecord) ProtoMessage() {} func (*TokenizeShareRecord) Descriptor() ([]byte, []int) { - return fileDescriptor_83fe2aa3458e6a34, []int{1} + return fileDescriptor_7b1e248decf35ce8, []int{1} } func (m *TokenizeShareRecord) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -188,7 +188,7 @@ func (m *PendingTokenizeShareAuthorizations) Reset() { *m = PendingToken func (m *PendingTokenizeShareAuthorizations) String() string { return proto.CompactTextString(m) } func (*PendingTokenizeShareAuthorizations) ProtoMessage() {} func (*PendingTokenizeShareAuthorizations) Descriptor() ([]byte, []int) { - return fileDescriptor_83fe2aa3458e6a34, []int{2} + return fileDescriptor_7b1e248decf35ce8, []int{2} } func (m *PendingTokenizeShareAuthorizations) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -234,7 +234,7 @@ func (m *TokenizeShareRecordReward) Reset() { *m = TokenizeShareRecordRe func (m *TokenizeShareRecordReward) String() string { return proto.CompactTextString(m) } func (*TokenizeShareRecordReward) ProtoMessage() {} func (*TokenizeShareRecordReward) Descriptor() ([]byte, []int) { - return fileDescriptor_83fe2aa3458e6a34, []int{3} + return fileDescriptor_7b1e248decf35ce8, []int{3} } func (m *TokenizeShareRecordReward) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -277,7 +277,7 @@ func (m *LiquidValidator) Reset() { *m = LiquidValidator{} } func (m *LiquidValidator) String() string { return proto.CompactTextString(m) } func (*LiquidValidator) ProtoMessage() {} func (*LiquidValidator) Descriptor() ([]byte, []int) { - return fileDescriptor_83fe2aa3458e6a34, []int{4} + return fileDescriptor_7b1e248decf35ce8, []int{4} } func (m *LiquidValidator) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -307,66 +307,65 @@ func (m *LiquidValidator) XXX_DiscardUnknown() { var xxx_messageInfo_LiquidValidator proto.InternalMessageInfo func init() { - proto.RegisterEnum("kyve.liquid.v1beta1.TokenizeShareLockStatus", TokenizeShareLockStatus_name, TokenizeShareLockStatus_value) - proto.RegisterType((*Params)(nil), "kyve.liquid.v1beta1.Params") - proto.RegisterType((*TokenizeShareRecord)(nil), "kyve.liquid.v1beta1.TokenizeShareRecord") - proto.RegisterType((*PendingTokenizeShareAuthorizations)(nil), "kyve.liquid.v1beta1.PendingTokenizeShareAuthorizations") - proto.RegisterType((*TokenizeShareRecordReward)(nil), "kyve.liquid.v1beta1.TokenizeShareRecordReward") - proto.RegisterType((*LiquidValidator)(nil), "kyve.liquid.v1beta1.LiquidValidator") + proto.RegisterEnum("gaia.liquid.v1beta1.TokenizeShareLockStatus", TokenizeShareLockStatus_name, TokenizeShareLockStatus_value) + proto.RegisterType((*Params)(nil), "gaia.liquid.v1beta1.Params") + proto.RegisterType((*TokenizeShareRecord)(nil), "gaia.liquid.v1beta1.TokenizeShareRecord") + proto.RegisterType((*PendingTokenizeShareAuthorizations)(nil), "gaia.liquid.v1beta1.PendingTokenizeShareAuthorizations") + proto.RegisterType((*TokenizeShareRecordReward)(nil), "gaia.liquid.v1beta1.TokenizeShareRecordReward") + proto.RegisterType((*LiquidValidator)(nil), "gaia.liquid.v1beta1.LiquidValidator") } -func init() { proto.RegisterFile("kyve/liquid/v1beta1/liquid.proto", fileDescriptor_83fe2aa3458e6a34) } +func init() { proto.RegisterFile("gaia/liquid/v1beta1/liquid.proto", fileDescriptor_7b1e248decf35ce8) } -var fileDescriptor_83fe2aa3458e6a34 = []byte{ - // 762 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x54, 0x4d, 0x4f, 0xe3, 0x46, - 0x18, 0xce, 0x24, 0x29, 0x22, 0xd3, 0x02, 0xa9, 0x89, 0x5a, 0x07, 0xa8, 0x93, 0x1a, 0xd1, 0x46, - 0x69, 0x89, 0x45, 0xb9, 0xa5, 0xa7, 0x7c, 0xb8, 0x6d, 0x44, 0x14, 0x22, 0x3b, 0xa0, 0x16, 0xa9, - 0x72, 0x27, 0xf6, 0xc8, 0x19, 0x25, 0xf1, 0xa4, 0x1e, 0x07, 0x1a, 0x7e, 0x40, 0x85, 0x7a, 0xea, - 0xa5, 0x52, 0x4f, 0x15, 0x52, 0x2f, 0xab, 0x95, 0x56, 0xe2, 0xc0, 0x2f, 0xd8, 0x13, 0x7b, 0x43, - 0x9c, 0x56, 0x7b, 0x60, 0x11, 0x1c, 0xd8, 0xf3, 0xfe, 0x82, 0x95, 0x3d, 0x4e, 0x58, 0x56, 0x2c, - 0xcb, 0x25, 0x99, 0xf7, 0x79, 0x9f, 0x79, 0xfc, 0xbc, 0x1f, 0x36, 0xcc, 0x76, 0x47, 0xbb, 0x58, - 0xe9, 0x91, 0xdf, 0x87, 0xc4, 0x52, 0x76, 0xd7, 0xda, 0xd8, 0x43, 0x6b, 0x61, 0x58, 0x18, 0xb8, - 0xd4, 0xa3, 0xc2, 0xbc, 0xcf, 0x28, 0x84, 0x50, 0xc8, 0x58, 0x48, 0xd9, 0xd4, 0xa6, 0x41, 0x5e, - 0xf1, 0x4f, 0x9c, 0xba, 0xf0, 0x29, 0xea, 0x13, 0x87, 0x2a, 0xc1, 0x6f, 0x08, 0x49, 0x26, 0x65, - 0x7d, 0xca, 0x94, 0x36, 0x62, 0x78, 0xa2, 0x6f, 0x52, 0xe2, 0x84, 0xf9, 0x34, 0xcf, 0x1b, 0x5c, - 0x8b, 0x07, 0x3c, 0x25, 0x5f, 0x44, 0xe1, 0x54, 0x13, 0xb9, 0xa8, 0xcf, 0x84, 0x7f, 0x00, 0x4c, - 0xdb, 0x3d, 0xda, 0x46, 0x3d, 0x83, 0x1b, 0x31, 0x98, 0x87, 0xba, 0xc4, 0xb1, 0x0d, 0x13, 0x0d, - 0xc4, 0xe9, 0x2c, 0xc8, 0x25, 0xca, 0x3b, 0x27, 0xe7, 0x99, 0xc8, 0x8b, 0xf3, 0xcc, 0x22, 0x17, - 0x61, 0x56, 0xb7, 0x40, 0xa8, 0xd2, 0x47, 0x5e, 0xa7, 0x50, 0xc7, 0x36, 0x32, 0x47, 0x55, 0x6c, - 0xbe, 0x3e, 0xcf, 0x64, 0x47, 0xa8, 0xdf, 0x2b, 0xca, 0xef, 0x55, 0x93, 0xcf, 0x8e, 0x57, 0x61, - 0xe8, 0xa3, 0x8a, 0xcd, 0x47, 0xd7, 0x47, 0x79, 0xa0, 0x7d, 0xc6, 0xe9, 0xf5, 0x80, 0xad, 0x73, - 0x72, 0x05, 0x0d, 0x84, 0xff, 0x00, 0x5c, 0xda, 0x45, 0x3d, 0x62, 0x21, 0x8f, 0xba, 0x77, 0x59, - 0x4b, 0x04, 0xd6, 0x7e, 0x7d, 0x98, 0xb5, 0x65, 0x6e, 0xed, 0x3e, 0xc1, 0x3b, 0xdd, 0xa5, 0x27, - 0x37, 0xde, 0x35, 0x58, 0xfc, 0xe2, 0xd5, 0x61, 0x06, 0xfc, 0x75, 0x7d, 0x94, 0x4f, 0xd9, 0x88, - 0x20, 0xe5, 0x8f, 0xf1, 0xa4, 0x79, 0x5f, 0xe5, 0x3f, 0x01, 0x9c, 0x6f, 0xd1, 0x2e, 0x76, 0xc8, - 0x3e, 0xd6, 0x3b, 0xc8, 0xc5, 0x1a, 0x36, 0xa9, 0x6b, 0x09, 0xb3, 0x30, 0x4a, 0x2c, 0x11, 0x64, - 0x41, 0x2e, 0xae, 0x45, 0x89, 0x25, 0xa4, 0xe0, 0x47, 0x74, 0xcf, 0xc1, 0xae, 0x18, 0xf5, 0xeb, - 0xd1, 0x78, 0x20, 0xac, 0xc0, 0xd9, 0x3e, 0xb5, 0x86, 0x3d, 0x6c, 0x20, 0xd3, 0xa4, 0x43, 0xc7, - 0x13, 0x63, 0x41, 0x7a, 0x86, 0xa3, 0x25, 0x0e, 0x0a, 0x4b, 0x30, 0x31, 0x31, 0x28, 0xc6, 0x03, - 0xc6, 0x0d, 0x50, 0x8c, 0xfb, 0x0e, 0xe5, 0x32, 0x94, 0x9b, 0xd8, 0xb1, 0x88, 0x63, 0xdf, 0xb2, - 0x53, 0x1a, 0x7a, 0x1d, 0xea, 0x92, 0x7d, 0xe4, 0x11, 0xea, 0x30, 0x5f, 0x09, 0x59, 0x96, 0x8b, - 0x19, 0xc3, 0x4c, 0x04, 0xd9, 0x98, 0xaf, 0x34, 0x01, 0xe4, 0x27, 0x00, 0xa6, 0xef, 0x28, 0x46, - 0xc3, 0x7b, 0xc8, 0xb5, 0x84, 0x45, 0x98, 0x70, 0x83, 0xd8, 0x98, 0x54, 0x36, 0xcd, 0x81, 0x9a, - 0x25, 0x10, 0x38, 0xe5, 0x06, 0x34, 0x31, 0x9a, 0x8d, 0xe5, 0x3e, 0xfe, 0x6e, 0xa9, 0x10, 0xf6, - 0xd8, 0x5f, 0xdb, 0xf1, 0xd2, 0xfb, 0x0d, 0xaf, 0x50, 0xe2, 0x94, 0xd7, 0xfd, 0x71, 0x3e, 0x7e, - 0x99, 0xf9, 0xc6, 0x26, 0x5e, 0x67, 0xd8, 0x2e, 0x98, 0xb4, 0x1f, 0x6e, 0x6e, 0xf8, 0xb7, 0xca, - 0xac, 0xae, 0xe2, 0x8d, 0x06, 0x98, 0x8d, 0xef, 0x30, 0x2d, 0x7c, 0x40, 0x71, 0xfa, 0xe0, 0x30, - 0x13, 0xf9, 0xd7, 0xaf, 0xf9, 0x29, 0x80, 0x73, 0x7c, 0x60, 0xdb, 0xe3, 0x6e, 0x08, 0x15, 0x98, - 0xa4, 0x03, 0xec, 0x06, 0xd3, 0x0f, 0x2b, 0x0b, 0xcc, 0x26, 0xca, 0xe2, 0xd9, 0xf1, 0x6a, 0x2a, - 0x74, 0x55, 0xe2, 0x19, 0xdd, 0x73, 0x89, 0x63, 0x6b, 0x73, 0xe3, 0x1b, 0x21, 0x2c, 0xfc, 0x06, - 0x67, 0xc6, 0x9b, 0xe3, 0xb7, 0x81, 0xf1, 0xb1, 0x94, 0xbf, 0x7f, 0xd8, 0x16, 0xa6, 0xf8, 0x16, - 0xde, 0x52, 0x90, 0xb5, 0x4f, 0x78, 0x1c, 0xf4, 0x95, 0xdd, 0x14, 0x91, 0x7f, 0x06, 0xe0, 0xe7, - 0xb7, 0x9a, 0x5e, 0xa7, 0x66, 0x57, 0xf7, 0x90, 0x37, 0x64, 0x42, 0x1e, 0x7e, 0xd5, 0xda, 0xdc, - 0x50, 0x1b, 0xb5, 0x1d, 0xd5, 0xd0, 0x7f, 0x2a, 0x69, 0xaa, 0x51, 0xdf, 0xac, 0x6c, 0x18, 0x7a, - 0xab, 0xd4, 0xda, 0xd2, 0x8d, 0xad, 0x86, 0xde, 0x54, 0x2b, 0xb5, 0x1f, 0x6a, 0x6a, 0x35, 0x19, - 0x11, 0x56, 0xe0, 0x97, 0xf7, 0x70, 0xfd, 0xb3, 0x5a, 0x4d, 0x02, 0xe1, 0x6b, 0xb8, 0x7c, 0xaf, - 0x64, 0x48, 0x8c, 0x0a, 0xdf, 0xc2, 0xdc, 0x07, 0xf4, 0x0c, 0xf5, 0xe7, 0x66, 0x4d, 0xab, 0x35, - 0x7e, 0x4c, 0xc6, 0x16, 0xe2, 0x07, 0xff, 0x4b, 0x91, 0xb2, 0x7a, 0x72, 0x29, 0x81, 0xd3, 0x4b, - 0x09, 0x5c, 0x5c, 0x4a, 0xe0, 0xef, 0x2b, 0x29, 0x72, 0x7a, 0x25, 0x45, 0x9e, 0x5f, 0x49, 0x91, - 0x9d, 0xb7, 0x27, 0xbd, 0xf1, 0xcb, 0xb6, 0xda, 0xc0, 0xde, 0x1e, 0x75, 0xbb, 0x8a, 0xd9, 0x41, - 0xc4, 0xb9, 0x79, 0xab, 0x82, 0x91, 0xb7, 0xa7, 0x82, 0xcf, 0xd7, 0xfa, 0x9b, 0x00, 0x00, 0x00, - 0xff, 0xff, 0x02, 0x76, 0xe9, 0xa8, 0x5b, 0x05, 0x00, 0x00, +var fileDescriptor_7b1e248decf35ce8 = []byte{ + // 747 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x54, 0xcf, 0x4f, 0x13, 0x5b, + 0x14, 0xee, 0x6d, 0xfb, 0x08, 0xbd, 0xef, 0x01, 0x7d, 0x43, 0xf3, 0xde, 0x14, 0x78, 0xd3, 0xbe, + 0x21, 0x68, 0x53, 0xa5, 0x0d, 0xb2, 0xab, 0x0b, 0xd3, 0x5f, 0x6a, 0x43, 0x03, 0xcd, 0x4c, 0x31, + 0x86, 0xc4, 0x8c, 0xb7, 0x33, 0x37, 0xd3, 0x9b, 0xb6, 0x73, 0xeb, 0xdc, 0x29, 0x08, 0x7f, 0x80, + 0x21, 0xae, 0xdc, 0x98, 0xb8, 0x32, 0x24, 0x6e, 0x8c, 0x89, 0x09, 0x0b, 0xfe, 0x02, 0x57, 0xb8, + 0x23, 0xac, 0x8c, 0x0b, 0x24, 0xb0, 0xc0, 0xb5, 0x7f, 0x81, 0x99, 0xb9, 0xd3, 0x92, 0x2a, 0x22, + 0x9b, 0xf6, 0x9e, 0x73, 0xbe, 0xfb, 0xcd, 0x77, 0xce, 0x77, 0x66, 0x60, 0xd2, 0x44, 0x04, 0x65, + 0xdb, 0xe4, 0x49, 0x8f, 0x18, 0xd9, 0xf5, 0x85, 0x06, 0x76, 0xd0, 0x82, 0x1f, 0x66, 0xba, 0x36, + 0x75, 0xa8, 0x30, 0xe9, 0x22, 0x32, 0x7e, 0xca, 0x47, 0x4c, 0xc5, 0x4c, 0x6a, 0x52, 0xaf, 0x9e, + 0x75, 0x4f, 0x1c, 0x3a, 0xf5, 0x37, 0xea, 0x10, 0x8b, 0x66, 0xbd, 0x5f, 0x3f, 0x25, 0xe9, 0x94, + 0x75, 0x28, 0xcb, 0x36, 0x10, 0xc3, 0x03, 0x7e, 0x9d, 0x12, 0xcb, 0xaf, 0xc7, 0x79, 0x5d, 0xe3, + 0x5c, 0x3c, 0xe0, 0x25, 0xf9, 0x38, 0x08, 0x47, 0x6a, 0xc8, 0x46, 0x1d, 0x26, 0xbc, 0x04, 0x30, + 0x6e, 0xb6, 0x69, 0x03, 0xb5, 0x35, 0x2e, 0x44, 0x63, 0x0e, 0x6a, 0x11, 0xcb, 0xd4, 0x74, 0xd4, + 0x15, 0x47, 0x93, 0x20, 0x15, 0x29, 0xac, 0xed, 0x1f, 0x25, 0x02, 0x9f, 0x8f, 0x12, 0xd3, 0x9c, + 0x84, 0x19, 0xad, 0x0c, 0xa1, 0xd9, 0x0e, 0x72, 0x9a, 0x99, 0x2a, 0x36, 0x91, 0xbe, 0x59, 0xc2, + 0xfa, 0xb7, 0xa3, 0x44, 0x72, 0x13, 0x75, 0xda, 0x39, 0xf9, 0x97, 0x6c, 0xf2, 0xe1, 0xde, 0x3c, + 0xf4, 0x75, 0x94, 0xb0, 0xfe, 0xf6, 0x6c, 0x37, 0x0d, 0x94, 0x7f, 0x38, 0xbc, 0xea, 0xa1, 0x55, + 0x0e, 0x2e, 0xa2, 0xae, 0xf0, 0x1a, 0xc0, 0x99, 0x75, 0xd4, 0x26, 0x06, 0x72, 0xa8, 0x7d, 0x91, + 0xb4, 0x88, 0x27, 0xed, 0xd1, 0xd5, 0xa4, 0xcd, 0x72, 0x69, 0x97, 0x11, 0x5e, 0xa8, 0x2e, 0x3e, + 0xb8, 0xf1, 0xa3, 0xc0, 0xdc, 0x7f, 0x5f, 0x77, 0x12, 0xe0, 0xf9, 0xd9, 0x6e, 0x3a, 0xe6, 0xf9, + 0xfc, 0xb4, 0xef, 0x34, 0x9f, 0xab, 0xfc, 0x0c, 0xc0, 0xc9, 0x3a, 0x6d, 0x61, 0x8b, 0x6c, 0x61, + 0xb5, 0x89, 0x6c, 0xac, 0x60, 0x9d, 0xda, 0x86, 0x30, 0x0e, 0x83, 0xc4, 0x10, 0x41, 0x12, 0xa4, + 0xc2, 0x4a, 0x90, 0x18, 0x42, 0x0c, 0xfe, 0x41, 0x37, 0x2c, 0x6c, 0x8b, 0x41, 0xb7, 0x1f, 0x85, + 0x07, 0xc2, 0x1c, 0x1c, 0xef, 0x50, 0xa3, 0xd7, 0xc6, 0x1a, 0xd2, 0x75, 0xda, 0xb3, 0x1c, 0x31, + 0xe4, 0x95, 0xc7, 0x78, 0x36, 0xcf, 0x93, 0xc2, 0x0c, 0x8c, 0x0c, 0x04, 0x8a, 0x61, 0x0f, 0x71, + 0x9e, 0xc8, 0x85, 0x5d, 0x85, 0x72, 0x01, 0xca, 0x35, 0x6c, 0x19, 0xc4, 0x32, 0x87, 0xe4, 0xe4, + 0x7b, 0x4e, 0x93, 0xda, 0x64, 0x0b, 0x39, 0x84, 0x5a, 0xcc, 0x65, 0x42, 0x86, 0x61, 0x63, 0xc6, + 0x30, 0x13, 0x41, 0x32, 0xe4, 0x32, 0x0d, 0x12, 0xf2, 0x7b, 0x00, 0xe3, 0x17, 0x34, 0xa3, 0xe0, + 0x0d, 0x64, 0x1b, 0xc2, 0x34, 0x8c, 0xd8, 0x5e, 0xac, 0x0d, 0x3a, 0x1b, 0xe5, 0x89, 0x8a, 0x21, + 0x10, 0x38, 0x62, 0x7b, 0x30, 0x31, 0x98, 0x0c, 0xa5, 0xfe, 0xbc, 0x35, 0x93, 0xf1, 0x67, 0xec, + 0xae, 0x6d, 0x7f, 0xe9, 0xdd, 0x81, 0x17, 0x29, 0xb1, 0x0a, 0x8b, 0xae, 0x9d, 0xef, 0xbe, 0x24, + 0x6e, 0x98, 0xc4, 0x69, 0xf6, 0x1a, 0x19, 0x9d, 0x76, 0xfc, 0xcd, 0xf5, 0xff, 0xe6, 0x99, 0xd1, + 0xca, 0x3a, 0x9b, 0x5d, 0xcc, 0xfa, 0x77, 0x98, 0xe2, 0x3f, 0x20, 0x37, 0xba, 0xbd, 0x93, 0x08, + 0xbc, 0x72, 0x7b, 0xfe, 0x00, 0xe0, 0x04, 0x37, 0xec, 0x41, 0x7f, 0x1a, 0x42, 0x11, 0x46, 0x69, + 0x17, 0xdb, 0x9e, 0xfb, 0x7e, 0x67, 0x9e, 0xd8, 0x48, 0x41, 0x3c, 0xdc, 0x9b, 0x8f, 0xf9, 0xaa, + 0xf2, 0xbc, 0xa2, 0x3a, 0x36, 0xb1, 0x4c, 0x65, 0xa2, 0x7f, 0xc3, 0x4f, 0x0b, 0x8f, 0xe1, 0x58, + 0x7f, 0x73, 0xdc, 0x31, 0x30, 0x6e, 0x4b, 0xe1, 0xf6, 0xd5, 0xb6, 0x30, 0xc6, 0xb7, 0x70, 0x88, + 0x41, 0x56, 0xfe, 0xe2, 0xb1, 0x37, 0x57, 0x76, 0xde, 0x44, 0xfa, 0x23, 0x80, 0xff, 0x0e, 0x0d, + 0xbd, 0x4a, 0xf5, 0x96, 0xea, 0x20, 0xa7, 0xc7, 0x84, 0x34, 0xbc, 0x56, 0x5f, 0x59, 0x2a, 0x2f, + 0x57, 0xd6, 0xca, 0x9a, 0x7a, 0x3f, 0xaf, 0x94, 0xb5, 0xea, 0x4a, 0x71, 0x49, 0x53, 0xeb, 0xf9, + 0xfa, 0xaa, 0xaa, 0xad, 0x2e, 0xab, 0xb5, 0x72, 0xb1, 0x72, 0xb7, 0x52, 0x2e, 0x45, 0x03, 0xc2, + 0x1c, 0xfc, 0xff, 0x12, 0xac, 0x7b, 0x2e, 0x97, 0xa2, 0x40, 0xb8, 0x0e, 0x67, 0x2f, 0xa5, 0xf4, + 0x81, 0x41, 0xe1, 0x26, 0x4c, 0xfd, 0x86, 0x4f, 0x2b, 0x3f, 0xac, 0x55, 0x94, 0xca, 0xf2, 0xbd, + 0x68, 0x68, 0x2a, 0xbc, 0xfd, 0x46, 0x0a, 0x14, 0xee, 0xec, 0x9f, 0x48, 0xe0, 0xe0, 0x44, 0x02, + 0xc7, 0x27, 0x12, 0x78, 0x71, 0x2a, 0x05, 0x0e, 0x4e, 0xa5, 0xc0, 0xa7, 0x53, 0x29, 0xb0, 0x36, + 0xf7, 0xb3, 0xd3, 0xc3, 0xef, 0x93, 0x67, 0x76, 0x63, 0xc4, 0xfb, 0x70, 0x2d, 0x7e, 0x0f, 0x00, + 0x00, 0xff, 0xff, 0x0b, 0x71, 0x1b, 0x16, 0x55, 0x05, 0x00, 0x00, } func (this *Params) Equal(that interface{}) bool { diff --git a/x/liquid/types/query.pb.go b/x/liquid/types/query.pb.go index ef2c8011..c7d6bf8c 100644 --- a/x/liquid/types/query.pb.go +++ b/x/liquid/types/query.pb.go @@ -1,5 +1,5 @@ // Code generated by protoc-gen-gogo. DO NOT EDIT. -// source: kyve/liquid/v1beta1/query.proto +// source: gaia/liquid/v1beta1/query.proto package types @@ -43,7 +43,7 @@ func (m *QueryLiquidValidatorRequest) Reset() { *m = QueryLiquidValidato func (m *QueryLiquidValidatorRequest) String() string { return proto.CompactTextString(m) } func (*QueryLiquidValidatorRequest) ProtoMessage() {} func (*QueryLiquidValidatorRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_1a9d927347bb19fc, []int{0} + return fileDescriptor_a7f79c476d0ac005, []int{0} } func (m *QueryLiquidValidatorRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -89,7 +89,7 @@ func (m *QueryLiquidValidatorResponse) Reset() { *m = QueryLiquidValidat func (m *QueryLiquidValidatorResponse) String() string { return proto.CompactTextString(m) } func (*QueryLiquidValidatorResponse) ProtoMessage() {} func (*QueryLiquidValidatorResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_1a9d927347bb19fc, []int{1} + return fileDescriptor_a7f79c476d0ac005, []int{1} } func (m *QueryLiquidValidatorResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -136,7 +136,7 @@ func (m *QueryLiquidValidatorsRequest) Reset() { *m = QueryLiquidValidat func (m *QueryLiquidValidatorsRequest) String() string { return proto.CompactTextString(m) } func (*QueryLiquidValidatorsRequest) ProtoMessage() {} func (*QueryLiquidValidatorsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_1a9d927347bb19fc, []int{2} + return fileDescriptor_a7f79c476d0ac005, []int{2} } func (m *QueryLiquidValidatorsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -184,7 +184,7 @@ func (m *QueryLiquidValidatorsResponse) Reset() { *m = QueryLiquidValida func (m *QueryLiquidValidatorsResponse) String() string { return proto.CompactTextString(m) } func (*QueryLiquidValidatorsResponse) ProtoMessage() {} func (*QueryLiquidValidatorsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_1a9d927347bb19fc, []int{3} + return fileDescriptor_a7f79c476d0ac005, []int{3} } func (m *QueryLiquidValidatorsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -235,7 +235,7 @@ func (m *QueryParamsRequest) Reset() { *m = QueryParamsRequest{} } func (m *QueryParamsRequest) String() string { return proto.CompactTextString(m) } func (*QueryParamsRequest) ProtoMessage() {} func (*QueryParamsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_1a9d927347bb19fc, []int{4} + return fileDescriptor_a7f79c476d0ac005, []int{4} } func (m *QueryParamsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -274,7 +274,7 @@ func (m *QueryParamsResponse) Reset() { *m = QueryParamsResponse{} } func (m *QueryParamsResponse) String() string { return proto.CompactTextString(m) } func (*QueryParamsResponse) ProtoMessage() {} func (*QueryParamsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_1a9d927347bb19fc, []int{5} + return fileDescriptor_a7f79c476d0ac005, []int{5} } func (m *QueryParamsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -320,7 +320,7 @@ func (m *QueryTokenizeShareRecordByIdRequest) Reset() { *m = QueryTokeni func (m *QueryTokenizeShareRecordByIdRequest) String() string { return proto.CompactTextString(m) } func (*QueryTokenizeShareRecordByIdRequest) ProtoMessage() {} func (*QueryTokenizeShareRecordByIdRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_1a9d927347bb19fc, []int{6} + return fileDescriptor_a7f79c476d0ac005, []int{6} } func (m *QueryTokenizeShareRecordByIdRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -366,7 +366,7 @@ func (m *QueryTokenizeShareRecordByIdResponse) Reset() { *m = QueryToken func (m *QueryTokenizeShareRecordByIdResponse) String() string { return proto.CompactTextString(m) } func (*QueryTokenizeShareRecordByIdResponse) ProtoMessage() {} func (*QueryTokenizeShareRecordByIdResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_1a9d927347bb19fc, []int{7} + return fileDescriptor_a7f79c476d0ac005, []int{7} } func (m *QueryTokenizeShareRecordByIdResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -414,7 +414,7 @@ func (m *QueryTokenizeShareRecordByDenomRequest) Reset() { func (m *QueryTokenizeShareRecordByDenomRequest) String() string { return proto.CompactTextString(m) } func (*QueryTokenizeShareRecordByDenomRequest) ProtoMessage() {} func (*QueryTokenizeShareRecordByDenomRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_1a9d927347bb19fc, []int{8} + return fileDescriptor_a7f79c476d0ac005, []int{8} } func (m *QueryTokenizeShareRecordByDenomRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -462,7 +462,7 @@ func (m *QueryTokenizeShareRecordByDenomResponse) Reset() { func (m *QueryTokenizeShareRecordByDenomResponse) String() string { return proto.CompactTextString(m) } func (*QueryTokenizeShareRecordByDenomResponse) ProtoMessage() {} func (*QueryTokenizeShareRecordByDenomResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_1a9d927347bb19fc, []int{9} + return fileDescriptor_a7f79c476d0ac005, []int{9} } func (m *QueryTokenizeShareRecordByDenomResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -508,7 +508,7 @@ func (m *QueryTokenizeShareRecordsOwnedRequest) Reset() { *m = QueryToke func (m *QueryTokenizeShareRecordsOwnedRequest) String() string { return proto.CompactTextString(m) } func (*QueryTokenizeShareRecordsOwnedRequest) ProtoMessage() {} func (*QueryTokenizeShareRecordsOwnedRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_1a9d927347bb19fc, []int{10} + return fileDescriptor_a7f79c476d0ac005, []int{10} } func (m *QueryTokenizeShareRecordsOwnedRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -556,7 +556,7 @@ func (m *QueryTokenizeShareRecordsOwnedResponse) Reset() { func (m *QueryTokenizeShareRecordsOwnedResponse) String() string { return proto.CompactTextString(m) } func (*QueryTokenizeShareRecordsOwnedResponse) ProtoMessage() {} func (*QueryTokenizeShareRecordsOwnedResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_1a9d927347bb19fc, []int{11} + return fileDescriptor_a7f79c476d0ac005, []int{11} } func (m *QueryTokenizeShareRecordsOwnedResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -603,7 +603,7 @@ func (m *QueryAllTokenizeShareRecordsRequest) Reset() { *m = QueryAllTok func (m *QueryAllTokenizeShareRecordsRequest) String() string { return proto.CompactTextString(m) } func (*QueryAllTokenizeShareRecordsRequest) ProtoMessage() {} func (*QueryAllTokenizeShareRecordsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_1a9d927347bb19fc, []int{12} + return fileDescriptor_a7f79c476d0ac005, []int{12} } func (m *QueryAllTokenizeShareRecordsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -651,7 +651,7 @@ func (m *QueryAllTokenizeShareRecordsResponse) Reset() { *m = QueryAllTo func (m *QueryAllTokenizeShareRecordsResponse) String() string { return proto.CompactTextString(m) } func (*QueryAllTokenizeShareRecordsResponse) ProtoMessage() {} func (*QueryAllTokenizeShareRecordsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_1a9d927347bb19fc, []int{13} + return fileDescriptor_a7f79c476d0ac005, []int{13} } func (m *QueryAllTokenizeShareRecordsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -703,7 +703,7 @@ func (m *QueryLastTokenizeShareRecordIdRequest) Reset() { *m = QueryLast func (m *QueryLastTokenizeShareRecordIdRequest) String() string { return proto.CompactTextString(m) } func (*QueryLastTokenizeShareRecordIdRequest) ProtoMessage() {} func (*QueryLastTokenizeShareRecordIdRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_1a9d927347bb19fc, []int{14} + return fileDescriptor_a7f79c476d0ac005, []int{14} } func (m *QueryLastTokenizeShareRecordIdRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -744,7 +744,7 @@ func (m *QueryLastTokenizeShareRecordIdResponse) Reset() { func (m *QueryLastTokenizeShareRecordIdResponse) String() string { return proto.CompactTextString(m) } func (*QueryLastTokenizeShareRecordIdResponse) ProtoMessage() {} func (*QueryLastTokenizeShareRecordIdResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_1a9d927347bb19fc, []int{15} + return fileDescriptor_a7f79c476d0ac005, []int{15} } func (m *QueryLastTokenizeShareRecordIdResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -789,7 +789,7 @@ func (m *QueryTotalTokenizeSharedAssetsRequest) Reset() { *m = QueryTota func (m *QueryTotalTokenizeSharedAssetsRequest) String() string { return proto.CompactTextString(m) } func (*QueryTotalTokenizeSharedAssetsRequest) ProtoMessage() {} func (*QueryTotalTokenizeSharedAssetsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_1a9d927347bb19fc, []int{16} + return fileDescriptor_a7f79c476d0ac005, []int{16} } func (m *QueryTotalTokenizeSharedAssetsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -830,7 +830,7 @@ func (m *QueryTotalTokenizeSharedAssetsResponse) Reset() { func (m *QueryTotalTokenizeSharedAssetsResponse) String() string { return proto.CompactTextString(m) } func (*QueryTotalTokenizeSharedAssetsResponse) ProtoMessage() {} func (*QueryTotalTokenizeSharedAssetsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_1a9d927347bb19fc, []int{17} + return fileDescriptor_a7f79c476d0ac005, []int{17} } func (m *QueryTotalTokenizeSharedAssetsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -875,7 +875,7 @@ func (m *QueryTotalLiquidStaked) Reset() { *m = QueryTotalLiquidStaked{} func (m *QueryTotalLiquidStaked) String() string { return proto.CompactTextString(m) } func (*QueryTotalLiquidStaked) ProtoMessage() {} func (*QueryTotalLiquidStaked) Descriptor() ([]byte, []int) { - return fileDescriptor_1a9d927347bb19fc, []int{18} + return fileDescriptor_a7f79c476d0ac005, []int{18} } func (m *QueryTotalLiquidStaked) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -914,7 +914,7 @@ func (m *QueryTotalLiquidStakedResponse) Reset() { *m = QueryTotalLiquid func (m *QueryTotalLiquidStakedResponse) String() string { return proto.CompactTextString(m) } func (*QueryTotalLiquidStakedResponse) ProtoMessage() {} func (*QueryTotalLiquidStakedResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_1a9d927347bb19fc, []int{19} + return fileDescriptor_a7f79c476d0ac005, []int{19} } func (m *QueryTotalLiquidStakedResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -960,7 +960,7 @@ func (m *QueryTokenizeShareLockInfo) Reset() { *m = QueryTokenizeShareLo func (m *QueryTokenizeShareLockInfo) String() string { return proto.CompactTextString(m) } func (*QueryTokenizeShareLockInfo) ProtoMessage() {} func (*QueryTokenizeShareLockInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_1a9d927347bb19fc, []int{20} + return fileDescriptor_a7f79c476d0ac005, []int{20} } func (m *QueryTokenizeShareLockInfo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1007,7 +1007,7 @@ func (m *QueryTokenizeShareLockInfoResponse) Reset() { *m = QueryTokeniz func (m *QueryTokenizeShareLockInfoResponse) String() string { return proto.CompactTextString(m) } func (*QueryTokenizeShareLockInfoResponse) ProtoMessage() {} func (*QueryTokenizeShareLockInfoResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_1a9d927347bb19fc, []int{21} + return fileDescriptor_a7f79c476d0ac005, []int{21} } func (m *QueryTokenizeShareLockInfoResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1060,7 +1060,7 @@ func (m *QueryTokenizeShareRecordRewardRequest) Reset() { *m = QueryToke func (m *QueryTokenizeShareRecordRewardRequest) String() string { return proto.CompactTextString(m) } func (*QueryTokenizeShareRecordRewardRequest) ProtoMessage() {} func (*QueryTokenizeShareRecordRewardRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_1a9d927347bb19fc, []int{22} + return fileDescriptor_a7f79c476d0ac005, []int{22} } func (m *QueryTokenizeShareRecordRewardRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1104,7 +1104,7 @@ func (m *QueryTokenizeShareRecordRewardResponse) Reset() { func (m *QueryTokenizeShareRecordRewardResponse) String() string { return proto.CompactTextString(m) } func (*QueryTokenizeShareRecordRewardResponse) ProtoMessage() {} func (*QueryTokenizeShareRecordRewardResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_1a9d927347bb19fc, []int{23} + return fileDescriptor_a7f79c476d0ac005, []int{23} } func (m *QueryTokenizeShareRecordRewardResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1148,120 +1148,119 @@ func (m *QueryTokenizeShareRecordRewardResponse) GetTotal() github_com_cosmos_co } func init() { - proto.RegisterType((*QueryLiquidValidatorRequest)(nil), "kyve.liquid.v1beta1.QueryLiquidValidatorRequest") - proto.RegisterType((*QueryLiquidValidatorResponse)(nil), "kyve.liquid.v1beta1.QueryLiquidValidatorResponse") - proto.RegisterType((*QueryLiquidValidatorsRequest)(nil), "kyve.liquid.v1beta1.QueryLiquidValidatorsRequest") - proto.RegisterType((*QueryLiquidValidatorsResponse)(nil), "kyve.liquid.v1beta1.QueryLiquidValidatorsResponse") - proto.RegisterType((*QueryParamsRequest)(nil), "kyve.liquid.v1beta1.QueryParamsRequest") - proto.RegisterType((*QueryParamsResponse)(nil), "kyve.liquid.v1beta1.QueryParamsResponse") - proto.RegisterType((*QueryTokenizeShareRecordByIdRequest)(nil), "kyve.liquid.v1beta1.QueryTokenizeShareRecordByIdRequest") - proto.RegisterType((*QueryTokenizeShareRecordByIdResponse)(nil), "kyve.liquid.v1beta1.QueryTokenizeShareRecordByIdResponse") - proto.RegisterType((*QueryTokenizeShareRecordByDenomRequest)(nil), "kyve.liquid.v1beta1.QueryTokenizeShareRecordByDenomRequest") - proto.RegisterType((*QueryTokenizeShareRecordByDenomResponse)(nil), "kyve.liquid.v1beta1.QueryTokenizeShareRecordByDenomResponse") - proto.RegisterType((*QueryTokenizeShareRecordsOwnedRequest)(nil), "kyve.liquid.v1beta1.QueryTokenizeShareRecordsOwnedRequest") - proto.RegisterType((*QueryTokenizeShareRecordsOwnedResponse)(nil), "kyve.liquid.v1beta1.QueryTokenizeShareRecordsOwnedResponse") - proto.RegisterType((*QueryAllTokenizeShareRecordsRequest)(nil), "kyve.liquid.v1beta1.QueryAllTokenizeShareRecordsRequest") - proto.RegisterType((*QueryAllTokenizeShareRecordsResponse)(nil), "kyve.liquid.v1beta1.QueryAllTokenizeShareRecordsResponse") - proto.RegisterType((*QueryLastTokenizeShareRecordIdRequest)(nil), "kyve.liquid.v1beta1.QueryLastTokenizeShareRecordIdRequest") - proto.RegisterType((*QueryLastTokenizeShareRecordIdResponse)(nil), "kyve.liquid.v1beta1.QueryLastTokenizeShareRecordIdResponse") - proto.RegisterType((*QueryTotalTokenizeSharedAssetsRequest)(nil), "kyve.liquid.v1beta1.QueryTotalTokenizeSharedAssetsRequest") - proto.RegisterType((*QueryTotalTokenizeSharedAssetsResponse)(nil), "kyve.liquid.v1beta1.QueryTotalTokenizeSharedAssetsResponse") - proto.RegisterType((*QueryTotalLiquidStaked)(nil), "kyve.liquid.v1beta1.QueryTotalLiquidStaked") - proto.RegisterType((*QueryTotalLiquidStakedResponse)(nil), "kyve.liquid.v1beta1.QueryTotalLiquidStakedResponse") - proto.RegisterType((*QueryTokenizeShareLockInfo)(nil), "kyve.liquid.v1beta1.QueryTokenizeShareLockInfo") - proto.RegisterType((*QueryTokenizeShareLockInfoResponse)(nil), "kyve.liquid.v1beta1.QueryTokenizeShareLockInfoResponse") - proto.RegisterType((*QueryTokenizeShareRecordRewardRequest)(nil), "kyve.liquid.v1beta1.QueryTokenizeShareRecordRewardRequest") - proto.RegisterType((*QueryTokenizeShareRecordRewardResponse)(nil), "kyve.liquid.v1beta1.QueryTokenizeShareRecordRewardResponse") -} - -func init() { proto.RegisterFile("kyve/liquid/v1beta1/query.proto", fileDescriptor_1a9d927347bb19fc) } - -var fileDescriptor_1a9d927347bb19fc = []byte{ - // 1342 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x58, 0x4f, 0x6f, 0x1b, 0xc5, - 0x1b, 0xf6, 0xe6, 0xd7, 0xa4, 0xbf, 0x0e, 0xf4, 0xdf, 0x34, 0xb4, 0xee, 0xa6, 0xb5, 0xab, 0xa1, - 0xad, 0xad, 0x44, 0xf5, 0x36, 0x31, 0x69, 0xfe, 0x91, 0x40, 0xd2, 0xb4, 0x50, 0x88, 0x4a, 0x71, - 0x4b, 0x25, 0x2a, 0xa4, 0xd5, 0xc4, 0x3b, 0x71, 0x56, 0xb6, 0x77, 0x9c, 0x9d, 0x75, 0x52, 0xd7, - 0xf2, 0x05, 0x09, 0xa9, 0x47, 0x24, 0xbe, 0x40, 0x6f, 0x20, 0x0e, 0x88, 0x13, 0x12, 0x17, 0x0e, - 0x20, 0xa1, 0x5e, 0x10, 0x91, 0x90, 0x10, 0x07, 0x54, 0x4a, 0x82, 0x04, 0x67, 0x3e, 0x01, 0xda, - 0x99, 0xd9, 0x8d, 0xd7, 0xdd, 0x5d, 0xdb, 0x51, 0x2e, 0xb1, 0x77, 0xf6, 0x7d, 0xe6, 0x7d, 0x9e, - 0x99, 0xf7, 0x9d, 0x79, 0x1c, 0x90, 0x2e, 0x37, 0x36, 0x89, 0x56, 0x31, 0x37, 0xea, 0xa6, 0xa1, - 0x6d, 0x8e, 0xaf, 0x12, 0x07, 0x8f, 0x6b, 0x1b, 0x75, 0x62, 0x37, 0x72, 0x35, 0x9b, 0x3a, 0x14, - 0x9e, 0x72, 0x03, 0x72, 0x22, 0x20, 0x27, 0x03, 0xd4, 0xd1, 0x22, 0x65, 0x55, 0xca, 0xb4, 0x55, - 0xcc, 0x88, 0x88, 0xf6, 0xb1, 0x35, 0x5c, 0x32, 0x2d, 0xec, 0x98, 0xd4, 0x12, 0x13, 0xa8, 0xc3, - 0x25, 0x5a, 0xa2, 0xfc, 0xab, 0xe6, 0x7e, 0x93, 0xa3, 0xe7, 0x4a, 0x94, 0x96, 0x2a, 0x44, 0xc3, - 0x35, 0x53, 0xc3, 0x96, 0x45, 0x1d, 0x0e, 0x61, 0xf2, 0xed, 0x85, 0x30, 0x56, 0x92, 0x83, 0x88, - 0x48, 0xb5, 0x33, 0xf0, 0x22, 0x8a, 0xd4, 0xf4, 0xb2, 0x8e, 0xc8, 0xf7, 0x1e, 0xb9, 0x76, 0x4d, - 0xea, 0x49, 0x5c, 0x35, 0x2d, 0xaa, 0xf1, 0xbf, 0x62, 0x08, 0x2d, 0x83, 0x91, 0xf7, 0xdd, 0x88, - 0x15, 0x9e, 0xe4, 0x3e, 0xae, 0x98, 0x06, 0x76, 0xa8, 0x5d, 0x20, 0x1b, 0x75, 0xc2, 0x1c, 0x78, - 0x09, 0x1c, 0xdb, 0xf4, 0xc6, 0x74, 0x6c, 0x18, 0x76, 0x52, 0xb9, 0xa0, 0x64, 0x8f, 0x14, 0x8e, - 0xfa, 0xa3, 0x8b, 0x86, 0x61, 0xa3, 0x47, 0xe0, 0x5c, 0xf8, 0x2c, 0xac, 0x46, 0x2d, 0x46, 0xe0, - 0x03, 0x70, 0x42, 0xa8, 0xd0, 0x7d, 0x1c, 0x9f, 0xe8, 0xa5, 0x89, 0x8b, 0xb9, 0x90, 0x75, 0xce, - 0x75, 0xcc, 0xb3, 0x74, 0xe4, 0xe9, 0xb3, 0x74, 0xe2, 0x8b, 0xbf, 0xbf, 0x1e, 0x55, 0x0a, 0xc7, - 0x2b, 0xc1, 0x77, 0x68, 0x2d, 0x3c, 0x37, 0xf3, 0x24, 0xdc, 0x04, 0x60, 0x6f, 0x6f, 0x64, 0xd6, - 0xcb, 0x39, 0xb1, 0x4c, 0x39, 0x77, 0x19, 0x73, 0x62, 0x89, 0xbc, 0xdc, 0x77, 0x70, 0x89, 0x48, - 0x6c, 0xa1, 0x0d, 0x89, 0x7e, 0x54, 0xc0, 0xf9, 0x88, 0x44, 0x52, 0xe5, 0x47, 0xe0, 0x64, 0xa7, - 0x4a, 0x96, 0x54, 0x2e, 0xfc, 0x6f, 0x3f, 0x32, 0x4f, 0x74, 0xc8, 0x64, 0xf0, 0xad, 0x80, 0x8e, - 0x01, 0xae, 0x23, 0xd3, 0x55, 0x87, 0xa0, 0x16, 0x10, 0x32, 0x0c, 0x20, 0xd7, 0x71, 0x07, 0xdb, - 0xb8, 0xea, 0x2d, 0x13, 0xfa, 0x00, 0x9c, 0x0a, 0x8c, 0x4a, 0x4d, 0x0b, 0x60, 0xa8, 0xc6, 0x47, - 0xe4, 0xca, 0x8d, 0x84, 0x0a, 0x11, 0xa0, 0x76, 0xfe, 0x12, 0x85, 0x26, 0xc1, 0xab, 0x7c, 0xda, - 0x7b, 0xb4, 0x4c, 0x2c, 0xf3, 0x11, 0xb9, 0xbb, 0x8e, 0x6d, 0x52, 0x20, 0x45, 0x6a, 0x1b, 0x4b, - 0x8d, 0x5b, 0x86, 0xb7, 0x49, 0xc7, 0xc0, 0x80, 0x69, 0xf0, 0x14, 0x87, 0x0a, 0x03, 0xa6, 0x81, - 0x2c, 0x70, 0x31, 0x1e, 0x26, 0xe9, 0xdd, 0x04, 0x43, 0x36, 0x1f, 0x95, 0xf4, 0xb2, 0xa1, 0xf4, - 0xc2, 0x66, 0x39, 0xe4, 0x72, 0x2d, 0x48, 0x34, 0x5a, 0x00, 0x97, 0xa3, 0xf3, 0x2d, 0x13, 0x8b, - 0x56, 0x3d, 0xa6, 0xc3, 0x60, 0xd0, 0x70, 0x9f, 0x65, 0x23, 0x88, 0x07, 0xb4, 0x01, 0x32, 0x5d, - 0xf1, 0x07, 0x4c, 0x79, 0x1e, 0x5c, 0x8a, 0x4a, 0xc9, 0xde, 0xdb, 0xb2, 0x88, 0xd1, 0xc6, 0x98, - 0x6e, 0x59, 0xc4, 0x6b, 0x5d, 0xf1, 0x80, 0xec, 0x68, 0xc5, 0x1e, 0x5c, 0x12, 0x7e, 0x1b, 0x1c, - 0x16, 0x29, 0xbd, 0x62, 0xee, 0x97, 0xb1, 0x07, 0x47, 0x55, 0x59, 0x0c, 0x8b, 0x95, 0x4a, 0x58, - 0xda, 0x83, 0xee, 0xd8, 0x6f, 0x15, 0x59, 0x45, 0x91, 0xf9, 0x0e, 0x5a, 0xe1, 0xc1, 0x35, 0x69, - 0x46, 0xee, 0xee, 0x0a, 0x66, 0x4e, 0x48, 0x5e, 0xbf, 0x73, 0xd0, 0xb4, 0xdc, 0xc7, 0x98, 0x40, - 0xa9, 0xb2, 0xb3, 0xc7, 0x32, 0x7e, 0x01, 0x39, 0x38, 0xb8, 0x3e, 0xc6, 0x22, 0x63, 0xc4, 0xf1, - 0x8f, 0x06, 0xdd, 0x2f, 0x95, 0xc8, 0x40, 0x99, 0x62, 0x12, 0x0c, 0x6e, 0xe2, 0x4a, 0x9d, 0xc8, - 0x4d, 0x3b, 0x1b, 0x50, 0xee, 0x69, 0xbe, 0x4e, 0x4d, 0x4b, 0xae, 0x9b, 0x88, 0x46, 0x49, 0x70, - 0x7a, 0x2f, 0x81, 0x38, 0x14, 0xef, 0x3a, 0xb8, 0x4c, 0x0c, 0x34, 0x0d, 0x52, 0xe1, 0x6f, 0xfc, - 0x94, 0xa7, 0xc1, 0x90, 0xe3, 0x52, 0x62, 0xb2, 0xbc, 0xe5, 0x13, 0xba, 0x06, 0xd4, 0x17, 0xeb, - 0x7b, 0x85, 0x16, 0xcb, 0xb7, 0xac, 0x35, 0x0a, 0x93, 0xe0, 0xb0, 0x7b, 0x9b, 0x11, 0xe6, 0xc1, - 0xbc, 0x47, 0x44, 0x00, 0x8a, 0xc6, 0xb5, 0x67, 0x65, 0x0e, 0x76, 0xea, 0x7e, 0x56, 0xf1, 0x04, - 0x33, 0xe0, 0x38, 0x79, 0x58, 0x33, 0x6d, 0xbe, 0x89, 0xba, 0x63, 0x56, 0x09, 0x2f, 0x82, 0x23, - 0x85, 0x63, 0x7b, 0xc3, 0xf7, 0xcc, 0x2a, 0x41, 0xb5, 0xe8, 0xee, 0x2d, 0x90, 0x2d, 0x6c, 0xfb, - 0xdd, 0x3b, 0x0f, 0x8e, 0xf2, 0x86, 0xd5, 0x03, 0x7c, 0x97, 0x92, 0xff, 0x3e, 0x4b, 0x0f, 0x37, - 0x70, 0xb5, 0x32, 0x8b, 0x02, 0xaf, 0x51, 0xe1, 0x65, 0xfe, 0xbc, 0x28, 0x1e, 0x67, 0xff, 0xff, - 0xf8, 0x49, 0x3a, 0xf1, 0xcf, 0x93, 0x74, 0x02, 0xfd, 0xa9, 0x44, 0x77, 0xbc, 0x97, 0x52, 0xaa, - 0xbb, 0xed, 0xf6, 0x83, 0x3b, 0xe2, 0xf5, 0x43, 0xae, 0xd7, 0x7e, 0x10, 0x13, 0xed, 0x75, 0x05, - 0x9f, 0x04, 0x96, 0xc0, 0xa0, 0xe3, 0x6e, 0x60, 0x72, 0x80, 0xcf, 0x76, 0x2e, 0xb4, 0x2c, 0x96, - 0x49, 0x91, 0x57, 0x46, 0xde, 0xc5, 0x7e, 0xf9, 0x47, 0x7a, 0xac, 0x64, 0x3a, 0xeb, 0xf5, 0xd5, - 0x5c, 0x91, 0x56, 0x35, 0x69, 0x6a, 0xc4, 0xc7, 0x15, 0x66, 0x94, 0x35, 0xa7, 0x51, 0x23, 0xcc, - 0xc3, 0xb0, 0x82, 0x98, 0x7f, 0xe2, 0x3b, 0x08, 0x06, 0xb9, 0x46, 0xf8, 0x95, 0x02, 0x4e, 0x74, - 0x5e, 0xd4, 0x70, 0x3c, 0x54, 0x46, 0x9c, 0x7b, 0x50, 0x27, 0xfa, 0x81, 0x88, 0xe5, 0x43, 0xf9, - 0xc7, 0xee, 0x15, 0xf8, 0xf1, 0x2f, 0x7f, 0x7d, 0x36, 0x90, 0x85, 0x97, 0xb5, 0x12, 0x36, 0x71, - 0xb8, 0xa7, 0x6b, 0xf3, 0x09, 0xf0, 0x1b, 0x05, 0x1c, 0xef, 0x98, 0x11, 0x5e, 0xed, 0x39, 0xb9, - 0x47, 0x77, 0xbc, 0x0f, 0x84, 0x64, 0xbb, 0xc0, 0x89, 0x4e, 0xc3, 0x6b, 0x3d, 0x11, 0xd5, 0x9a, - 0x41, 0x3f, 0xd8, 0x82, 0x3f, 0x29, 0xe0, 0x4c, 0xc4, 0x35, 0x0d, 0xa7, 0xa3, 0xe9, 0xc4, 0x1b, - 0x02, 0x75, 0x66, 0x1f, 0x48, 0x29, 0x68, 0x9e, 0x0b, 0x9a, 0x82, 0x93, 0xa1, 0x82, 0x1c, 0x89, - 0xd6, 0x99, 0x0b, 0xd7, 0xc5, 0xc1, 0xad, 0xaf, 0x36, 0x74, 0xd3, 0xd0, 0x9a, 0xa6, 0xd1, 0x82, - 0xbf, 0x2b, 0x40, 0x8d, 0xbe, 0xc6, 0xe1, 0x5c, 0x9f, 0xc4, 0xda, 0xcd, 0x83, 0xfa, 0xfa, 0xfe, - 0xc0, 0x52, 0xd8, 0x75, 0x2e, 0x6c, 0x1e, 0xce, 0xf5, 0x27, 0x8c, 0x3b, 0x14, 0xad, 0xc9, 0x3f, - 0x5a, 0xf0, 0x57, 0x05, 0x9c, 0x8d, 0xbc, 0xf3, 0xe1, 0x6c, 0x5f, 0x04, 0x03, 0x3e, 0x43, 0x9d, - 0xdb, 0x17, 0x56, 0x6a, 0x7b, 0x93, 0x6b, 0x9b, 0x85, 0xd3, 0x7d, 0x68, 0x73, 0x0f, 0x3a, 0x43, - 0x6b, 0xf2, 0xf3, 0xae, 0x05, 0x7f, 0x50, 0xc0, 0x99, 0x88, 0x8b, 0x3e, 0xae, 0x0e, 0xe3, 0xbd, - 0x48, 0x5c, 0x1d, 0x76, 0x71, 0x15, 0x28, 0xcf, 0x25, 0x5d, 0x81, 0x63, 0xbd, 0x4b, 0x62, 0x70, - 0x5b, 0x01, 0x67, 0x23, 0xaf, 0xf2, 0xb8, 0xed, 0xe9, 0x66, 0x14, 0xe2, 0xb6, 0xa7, 0xab, 0x77, - 0x40, 0xb3, 0x5c, 0xcb, 0x6b, 0x70, 0x22, 0xfc, 0x90, 0xc0, 0xcc, 0xd1, 0xc3, 0xf7, 0xc8, 0x34, - 0xe0, 0xcf, 0xbc, 0xe2, 0x22, 0xac, 0x43, 0x7c, 0xc5, 0xc5, 0x1b, 0x93, 0xf8, 0x8a, 0xeb, 0xe2, - 0x55, 0xd0, 0x0c, 0x97, 0x94, 0x87, 0xe3, 0x11, 0xdb, 0xe3, 0xe0, 0x4a, 0x87, 0x26, 0x43, 0xc7, - 0x82, 0xf3, 0xe7, 0x0a, 0x38, 0xf9, 0x82, 0x23, 0x81, 0x63, 0x5d, 0xd8, 0xb4, 0x07, 0xab, 0xf9, - 0x3e, 0x82, 0x7d, 0xca, 0x57, 0x39, 0xe5, 0x51, 0x98, 0x8d, 0xa1, 0x2c, 0x0f, 0x6c, 0x26, 0x38, - 0x7d, 0xaf, 0x80, 0x57, 0xc2, 0x1d, 0x90, 0xd6, 0x63, 0xb7, 0x7a, 0x00, 0x75, 0xaa, 0x4f, 0x80, - 0xcf, 0xfa, 0x0d, 0xce, 0x7a, 0x06, 0x4e, 0xf5, 0xd2, 0x07, 0x15, 0x5a, 0x2c, 0xeb, 0xa6, 0xb5, - 0x46, 0xb5, 0xa6, 0x74, 0x34, 0x2d, 0xf8, 0x89, 0x02, 0x86, 0xc4, 0x2f, 0x4c, 0x98, 0x89, 0x26, - 0x11, 0xf8, 0x39, 0xab, 0x66, 0xbb, 0x07, 0x4a, 0x7a, 0xd9, 0xbd, 0xdb, 0xfa, 0x3c, 0x1c, 0x09, - 0xe5, 0x28, 0x7e, 0xcb, 0xc2, 0xe7, 0xe1, 0x47, 0xa7, 0xf0, 0x3c, 0x7d, 0x1e, 0x9d, 0x01, 0x93, - 0xd7, 0xe7, 0xd1, 0x19, 0x74, 0x6b, 0xe8, 0x1d, 0xce, 0x7d, 0x19, 0x2e, 0x85, 0x72, 0x6f, 0x06, - 0xec, 0x61, 0x2b, 0xe2, 0x28, 0x95, 0x4e, 0x6d, 0xe9, 0xc6, 0xd3, 0x9d, 0x94, 0xb2, 0xbd, 0x93, - 0x52, 0x9e, 0xef, 0xa4, 0x94, 0x4f, 0x77, 0x53, 0x89, 0xed, 0xdd, 0x54, 0xe2, 0xb7, 0xdd, 0x54, - 0xe2, 0x41, 0xbb, 0x1d, 0x7b, 0xf7, 0xc3, 0xfb, 0x37, 0x6e, 0x13, 0x67, 0x8b, 0xda, 0x65, 0xad, - 0xb8, 0x8e, 0x4d, 0x4b, 0x7b, 0xe8, 0xa5, 0xe5, 0xbe, 0x6c, 0x75, 0x88, 0xff, 0x73, 0x29, 0xff, - 0x5f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xf6, 0x76, 0x6c, 0xeb, 0x66, 0x13, 0x00, 0x00, + proto.RegisterType((*QueryLiquidValidatorRequest)(nil), "gaia.liquid.v1beta1.QueryLiquidValidatorRequest") + proto.RegisterType((*QueryLiquidValidatorResponse)(nil), "gaia.liquid.v1beta1.QueryLiquidValidatorResponse") + proto.RegisterType((*QueryLiquidValidatorsRequest)(nil), "gaia.liquid.v1beta1.QueryLiquidValidatorsRequest") + proto.RegisterType((*QueryLiquidValidatorsResponse)(nil), "gaia.liquid.v1beta1.QueryLiquidValidatorsResponse") + proto.RegisterType((*QueryParamsRequest)(nil), "gaia.liquid.v1beta1.QueryParamsRequest") + proto.RegisterType((*QueryParamsResponse)(nil), "gaia.liquid.v1beta1.QueryParamsResponse") + proto.RegisterType((*QueryTokenizeShareRecordByIdRequest)(nil), "gaia.liquid.v1beta1.QueryTokenizeShareRecordByIdRequest") + proto.RegisterType((*QueryTokenizeShareRecordByIdResponse)(nil), "gaia.liquid.v1beta1.QueryTokenizeShareRecordByIdResponse") + proto.RegisterType((*QueryTokenizeShareRecordByDenomRequest)(nil), "gaia.liquid.v1beta1.QueryTokenizeShareRecordByDenomRequest") + proto.RegisterType((*QueryTokenizeShareRecordByDenomResponse)(nil), "gaia.liquid.v1beta1.QueryTokenizeShareRecordByDenomResponse") + proto.RegisterType((*QueryTokenizeShareRecordsOwnedRequest)(nil), "gaia.liquid.v1beta1.QueryTokenizeShareRecordsOwnedRequest") + proto.RegisterType((*QueryTokenizeShareRecordsOwnedResponse)(nil), "gaia.liquid.v1beta1.QueryTokenizeShareRecordsOwnedResponse") + proto.RegisterType((*QueryAllTokenizeShareRecordsRequest)(nil), "gaia.liquid.v1beta1.QueryAllTokenizeShareRecordsRequest") + proto.RegisterType((*QueryAllTokenizeShareRecordsResponse)(nil), "gaia.liquid.v1beta1.QueryAllTokenizeShareRecordsResponse") + proto.RegisterType((*QueryLastTokenizeShareRecordIdRequest)(nil), "gaia.liquid.v1beta1.QueryLastTokenizeShareRecordIdRequest") + proto.RegisterType((*QueryLastTokenizeShareRecordIdResponse)(nil), "gaia.liquid.v1beta1.QueryLastTokenizeShareRecordIdResponse") + proto.RegisterType((*QueryTotalTokenizeSharedAssetsRequest)(nil), "gaia.liquid.v1beta1.QueryTotalTokenizeSharedAssetsRequest") + proto.RegisterType((*QueryTotalTokenizeSharedAssetsResponse)(nil), "gaia.liquid.v1beta1.QueryTotalTokenizeSharedAssetsResponse") + proto.RegisterType((*QueryTotalLiquidStaked)(nil), "gaia.liquid.v1beta1.QueryTotalLiquidStaked") + proto.RegisterType((*QueryTotalLiquidStakedResponse)(nil), "gaia.liquid.v1beta1.QueryTotalLiquidStakedResponse") + proto.RegisterType((*QueryTokenizeShareLockInfo)(nil), "gaia.liquid.v1beta1.QueryTokenizeShareLockInfo") + proto.RegisterType((*QueryTokenizeShareLockInfoResponse)(nil), "gaia.liquid.v1beta1.QueryTokenizeShareLockInfoResponse") + proto.RegisterType((*QueryTokenizeShareRecordRewardRequest)(nil), "gaia.liquid.v1beta1.QueryTokenizeShareRecordRewardRequest") + proto.RegisterType((*QueryTokenizeShareRecordRewardResponse)(nil), "gaia.liquid.v1beta1.QueryTokenizeShareRecordRewardResponse") +} + +func init() { proto.RegisterFile("gaia/liquid/v1beta1/query.proto", fileDescriptor_a7f79c476d0ac005) } + +var fileDescriptor_a7f79c476d0ac005 = []byte{ + // 1323 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x58, 0xcf, 0x6f, 0x1b, 0x45, + 0x14, 0xf6, 0x86, 0x26, 0xa5, 0x03, 0xfd, 0x91, 0x69, 0x68, 0x9d, 0x4d, 0x6a, 0x47, 0x43, 0x13, + 0x5b, 0x89, 0xea, 0x6d, 0x62, 0xd2, 0xfc, 0x22, 0x29, 0x49, 0xa3, 0x42, 0x51, 0x04, 0xc5, 0x2d, + 0x1c, 0x2a, 0xa4, 0xd5, 0xc4, 0x3b, 0x71, 0x57, 0xb1, 0x77, 0x9c, 0x9d, 0x75, 0xd2, 0xd4, 0xf2, + 0x05, 0x09, 0xa9, 0x47, 0x24, 0xfe, 0x81, 0xde, 0x40, 0x1c, 0x10, 0x27, 0x24, 0x2e, 0x1c, 0x40, + 0x42, 0xbd, 0x20, 0x22, 0x21, 0x21, 0x0e, 0xa8, 0x94, 0x04, 0x09, 0xce, 0xfc, 0x05, 0x68, 0x67, + 0x66, 0x37, 0x5e, 0x67, 0x77, 0x6d, 0x47, 0xb9, 0xc4, 0xde, 0xd9, 0xf7, 0xcd, 0xfb, 0xbe, 0x99, + 0xf7, 0x66, 0x3e, 0x07, 0xa4, 0x4b, 0xd8, 0xc4, 0x5a, 0xd9, 0xdc, 0xaa, 0x99, 0x86, 0xb6, 0x3d, + 0xb9, 0x4e, 0x1c, 0x3c, 0xa9, 0x6d, 0xd5, 0x88, 0xbd, 0x9b, 0xab, 0xda, 0xd4, 0xa1, 0xf0, 0xa2, + 0x1b, 0x90, 0x13, 0x01, 0x39, 0x19, 0xa0, 0x8e, 0x17, 0x29, 0xab, 0x50, 0xa6, 0xad, 0x63, 0x46, + 0x44, 0xb4, 0x8f, 0xad, 0xe2, 0x92, 0x69, 0x61, 0xc7, 0xa4, 0x96, 0x98, 0x40, 0x1d, 0x28, 0xd1, + 0x12, 0xe5, 0x5f, 0x35, 0xf7, 0x9b, 0x1c, 0x1d, 0x2e, 0x51, 0x5a, 0x2a, 0x13, 0x0d, 0x57, 0x4d, + 0x0d, 0x5b, 0x16, 0x75, 0x38, 0x84, 0xc9, 0xb7, 0x23, 0x61, 0xac, 0x24, 0x07, 0x11, 0x91, 0x6a, + 0x66, 0xe0, 0x45, 0x14, 0xa9, 0xe9, 0x65, 0x1d, 0x92, 0xef, 0x3d, 0x72, 0xcd, 0x9a, 0xd4, 0x7e, + 0x5c, 0x31, 0x2d, 0xaa, 0xf1, 0xbf, 0x62, 0x08, 0xad, 0x82, 0xa1, 0x0f, 0xdc, 0x88, 0x35, 0x9e, + 0xe4, 0x23, 0x5c, 0x36, 0x0d, 0xec, 0x50, 0xbb, 0x40, 0xb6, 0x6a, 0x84, 0x39, 0x70, 0x14, 0x9c, + 0xdb, 0xf6, 0xc6, 0x74, 0x6c, 0x18, 0x76, 0x52, 0x19, 0x51, 0xb2, 0x67, 0x0a, 0x67, 0xfd, 0xd1, + 0x65, 0xc3, 0xb0, 0xd1, 0x63, 0x30, 0x1c, 0x3e, 0x0b, 0xab, 0x52, 0x8b, 0x11, 0xf8, 0x00, 0x5c, + 0x10, 0x2a, 0x74, 0x1f, 0xc7, 0x27, 0x7a, 0x65, 0xea, 0x6a, 0x2e, 0x64, 0x9d, 0x73, 0x2d, 0xf3, + 0xac, 0x9c, 0x79, 0xf6, 0x3c, 0x9d, 0xf8, 0xf2, 0x9f, 0x6f, 0xc6, 0x95, 0xc2, 0xf9, 0x72, 0xf0, + 0x1d, 0xda, 0x08, 0xcf, 0xcd, 0x3c, 0x09, 0xb7, 0x01, 0x38, 0xdc, 0x1b, 0x99, 0x75, 0x2c, 0x27, + 0x96, 0x29, 0xe7, 0x2e, 0x63, 0x4e, 0x2c, 0x91, 0x97, 0xfb, 0x2e, 0x2e, 0x11, 0x89, 0x2d, 0x34, + 0x21, 0xd1, 0x4f, 0x0a, 0xb8, 0x12, 0x91, 0x48, 0xaa, 0xfc, 0x18, 0xf4, 0xb7, 0xaa, 0x64, 0x49, + 0x65, 0xe4, 0xa5, 0xe3, 0xc8, 0xbc, 0xd0, 0x22, 0x93, 0xc1, 0xb7, 0x03, 0x3a, 0x7a, 0xb8, 0x8e, + 0x4c, 0x5b, 0x1d, 0x82, 0x5a, 0x40, 0xc8, 0x00, 0x80, 0x5c, 0xc7, 0x5d, 0x6c, 0xe3, 0x8a, 0xb7, + 0x4c, 0xe8, 0x43, 0x70, 0x31, 0x30, 0x2a, 0x35, 0x2d, 0x81, 0xbe, 0x2a, 0x1f, 0x91, 0x2b, 0x37, + 0x14, 0x2a, 0x44, 0x80, 0x9a, 0xf9, 0x4b, 0x14, 0x9a, 0x06, 0xaf, 0xf3, 0x69, 0xef, 0xd3, 0x4d, + 0x62, 0x99, 0x8f, 0xc9, 0xbd, 0x87, 0xd8, 0x26, 0x05, 0x52, 0xa4, 0xb6, 0xb1, 0xb2, 0x7b, 0xc7, + 0xf0, 0x36, 0xe9, 0x1c, 0xe8, 0x31, 0x0d, 0x9e, 0xe2, 0x54, 0xa1, 0xc7, 0x34, 0x90, 0x05, 0xae, + 0xc6, 0xc3, 0x24, 0xbd, 0xdb, 0xa0, 0xcf, 0xe6, 0xa3, 0x92, 0x5e, 0x36, 0x94, 0x5e, 0xd8, 0x2c, + 0xa7, 0x5c, 0xae, 0x05, 0x89, 0x46, 0x4b, 0x60, 0x2c, 0x3a, 0xdf, 0x2a, 0xb1, 0x68, 0xc5, 0x63, + 0x3a, 0x00, 0x7a, 0x0d, 0xf7, 0x59, 0x36, 0x82, 0x78, 0x40, 0x5b, 0x20, 0xd3, 0x16, 0x7f, 0xc2, + 0x94, 0x17, 0xc1, 0x68, 0x54, 0x4a, 0xf6, 0xfe, 0x8e, 0x45, 0x8c, 0x26, 0xc6, 0x74, 0xc7, 0x22, + 0x5e, 0xeb, 0x8a, 0x07, 0x64, 0x47, 0x2b, 0xf6, 0xe0, 0x92, 0xf0, 0x3b, 0xe0, 0xb4, 0x48, 0xe9, + 0x15, 0x73, 0xb7, 0x8c, 0x3d, 0x38, 0xaa, 0xc8, 0x62, 0x58, 0x2e, 0x97, 0xc3, 0xd2, 0x9e, 0x74, + 0xc7, 0x7e, 0xa7, 0xc8, 0x2a, 0x8a, 0xcc, 0x77, 0xd2, 0x0a, 0x4f, 0xae, 0x49, 0x33, 0x72, 0x77, + 0xd7, 0x30, 0x73, 0x42, 0xf2, 0xfa, 0x9d, 0x83, 0x66, 0xe5, 0x3e, 0xc6, 0x04, 0x4a, 0x95, 0xad, + 0x3d, 0x96, 0xf1, 0x0b, 0xc8, 0xc1, 0xc1, 0xf5, 0x31, 0x96, 0x19, 0x23, 0x8e, 0x7f, 0x34, 0xe8, + 0x7e, 0xa9, 0x44, 0x06, 0xca, 0x14, 0xd3, 0xa0, 0x77, 0x1b, 0x97, 0x6b, 0x44, 0x6e, 0xda, 0x60, + 0x40, 0xb9, 0xa7, 0xf9, 0x16, 0x35, 0x2d, 0xb9, 0x6e, 0x22, 0x1a, 0x25, 0xc1, 0xa5, 0xc3, 0x04, + 0xe2, 0x50, 0xbc, 0xe7, 0xe0, 0x4d, 0x62, 0xa0, 0x59, 0x90, 0x0a, 0x7f, 0xe3, 0xa7, 0xbc, 0x04, + 0xfa, 0x1c, 0x97, 0x12, 0x93, 0xe5, 0x2d, 0x9f, 0xd0, 0x0d, 0xa0, 0x1e, 0xad, 0xef, 0x35, 0x5a, + 0xdc, 0xbc, 0x63, 0x6d, 0x50, 0x98, 0x04, 0xa7, 0xdd, 0xdb, 0x8c, 0x30, 0x0f, 0xe6, 0x3d, 0x22, + 0x02, 0x50, 0x34, 0xae, 0x39, 0x2b, 0x73, 0xb0, 0x53, 0xf3, 0xb3, 0x8a, 0x27, 0x98, 0x01, 0xe7, + 0xc9, 0xa3, 0xaa, 0x69, 0xf3, 0x4d, 0xd4, 0x1d, 0xb3, 0x42, 0x78, 0x11, 0x9c, 0x29, 0x9c, 0x3b, + 0x1c, 0xbe, 0x6f, 0x56, 0x08, 0xaa, 0x46, 0x77, 0x6f, 0x81, 0xec, 0x60, 0xdb, 0xef, 0xde, 0x45, + 0x70, 0x96, 0x37, 0xac, 0x1e, 0xe0, 0xbb, 0x92, 0xfc, 0xef, 0x79, 0x7a, 0x60, 0x17, 0x57, 0xca, + 0xf3, 0x28, 0xf0, 0x1a, 0x15, 0x5e, 0xe5, 0xcf, 0xcb, 0xe2, 0x71, 0xfe, 0xe5, 0x27, 0x4f, 0xd3, + 0x89, 0x7f, 0x9f, 0xa6, 0x13, 0xe8, 0x2f, 0x25, 0xba, 0xe3, 0xbd, 0x94, 0x52, 0xdd, 0x7b, 0x6e, + 0x3f, 0xb8, 0x23, 0x5e, 0x3f, 0xe4, 0x3a, 0xed, 0x07, 0x31, 0xd1, 0x61, 0x57, 0xf0, 0x49, 0x60, + 0x09, 0xf4, 0x3a, 0xee, 0x06, 0x26, 0x7b, 0xf8, 0x6c, 0xc3, 0xa1, 0x65, 0xb1, 0x4a, 0x8a, 0xbc, + 0x32, 0xf2, 0x2e, 0xf6, 0xab, 0x3f, 0xd3, 0x13, 0x25, 0xd3, 0x79, 0x58, 0x5b, 0xcf, 0x15, 0x69, + 0x45, 0x93, 0xa6, 0x46, 0x7c, 0x5c, 0x63, 0xc6, 0xa6, 0xe6, 0xec, 0x56, 0x09, 0xf3, 0x30, 0xac, + 0x20, 0xe6, 0x9f, 0xfa, 0x1e, 0x82, 0x5e, 0xae, 0x11, 0x7e, 0xad, 0x80, 0x0b, 0xad, 0x17, 0x35, + 0x9c, 0x0c, 0x95, 0x11, 0xe7, 0x1e, 0xd4, 0xa9, 0x6e, 0x20, 0x62, 0xf9, 0x50, 0xfe, 0x89, 0x7b, + 0x05, 0x7e, 0xf2, 0xeb, 0xdf, 0x9f, 0xf7, 0x64, 0xe1, 0x98, 0x16, 0xed, 0xe9, 0x9a, 0x7c, 0x02, + 0xfc, 0x56, 0x01, 0xe7, 0x5b, 0x66, 0x84, 0xd7, 0x3b, 0x4e, 0xee, 0xd1, 0x9d, 0xec, 0x02, 0x21, + 0xd9, 0x2e, 0x71, 0xa2, 0xb3, 0xf0, 0x46, 0x47, 0x44, 0xb5, 0x7a, 0xd0, 0x0f, 0x36, 0xe0, 0xcf, + 0x0a, 0xb8, 0x1c, 0x71, 0x4d, 0xc3, 0xd9, 0x68, 0x3a, 0xf1, 0x86, 0x40, 0x9d, 0x3b, 0x06, 0x52, + 0x0a, 0x5a, 0xe4, 0x82, 0x66, 0xe0, 0x74, 0xa8, 0x20, 0x47, 0xa2, 0x75, 0xe6, 0xc2, 0x75, 0x71, + 0x70, 0xeb, 0xeb, 0xbb, 0xba, 0x69, 0x68, 0x75, 0xd3, 0x68, 0xc0, 0x3f, 0x14, 0xa0, 0x46, 0x5f, + 0xe3, 0x70, 0xa1, 0x4b, 0x62, 0xcd, 0xe6, 0x41, 0x7d, 0xf3, 0x78, 0x60, 0x29, 0xec, 0x16, 0x17, + 0xb6, 0x08, 0x17, 0xba, 0x13, 0xc6, 0x1d, 0x8a, 0x56, 0xe7, 0x1f, 0x0d, 0xf8, 0x9b, 0x02, 0x06, + 0x23, 0xef, 0x7c, 0x38, 0xdf, 0x15, 0xc1, 0x80, 0xcf, 0x50, 0x17, 0x8e, 0x85, 0x95, 0xda, 0xde, + 0xe2, 0xda, 0xe6, 0xe1, 0x6c, 0x17, 0xda, 0xdc, 0x83, 0xce, 0xd0, 0xea, 0xfc, 0xbc, 0x6b, 0xc0, + 0x1f, 0x15, 0x70, 0x39, 0xe2, 0xa2, 0x8f, 0xab, 0xc3, 0x78, 0x2f, 0x12, 0x57, 0x87, 0x6d, 0x5c, + 0x05, 0xca, 0x73, 0x49, 0xd7, 0xe0, 0x44, 0xe7, 0x92, 0x18, 0xdc, 0x53, 0xc0, 0x60, 0xe4, 0x55, + 0x1e, 0xb7, 0x3d, 0xed, 0x8c, 0x42, 0xdc, 0xf6, 0xb4, 0xf5, 0x0e, 0x68, 0x9e, 0x6b, 0x79, 0x03, + 0x4e, 0x85, 0x1f, 0x12, 0x98, 0x39, 0x7a, 0xf8, 0x1e, 0x99, 0x06, 0xfc, 0x85, 0x57, 0x5c, 0x84, + 0x75, 0x88, 0xaf, 0xb8, 0x78, 0x63, 0x12, 0x5f, 0x71, 0x6d, 0xbc, 0x0a, 0x9a, 0xe3, 0x92, 0xf2, + 0x70, 0x32, 0x62, 0x7b, 0x1c, 0x5c, 0x6e, 0xd1, 0x64, 0xe8, 0x58, 0x70, 0xfe, 0x42, 0x01, 0xfd, + 0x47, 0x1c, 0x09, 0x9c, 0x68, 0xc3, 0xa6, 0x39, 0x58, 0xcd, 0x77, 0x11, 0xec, 0x53, 0xbe, 0xce, + 0x29, 0x8f, 0xc3, 0x6c, 0x0c, 0x65, 0x79, 0x60, 0x33, 0xc1, 0xe9, 0x07, 0x05, 0xbc, 0x16, 0xee, + 0x80, 0xb4, 0x0e, 0xbb, 0xd5, 0x03, 0xa8, 0x33, 0x5d, 0x02, 0x7c, 0xd6, 0x37, 0x39, 0xeb, 0x39, + 0x38, 0xd3, 0x49, 0x1f, 0x94, 0x69, 0x71, 0x53, 0x37, 0xad, 0x0d, 0xaa, 0xd5, 0xa5, 0xa3, 0x69, + 0xc0, 0x4f, 0x15, 0xd0, 0x27, 0x7e, 0x61, 0xc2, 0x4c, 0x34, 0x89, 0xc0, 0xcf, 0x59, 0x35, 0xdb, + 0x3e, 0x50, 0xd2, 0xcb, 0x1e, 0xde, 0xd6, 0x57, 0xe0, 0x50, 0x28, 0x47, 0xf1, 0x5b, 0x16, 0xbe, + 0x08, 0x3f, 0x3a, 0x85, 0xe7, 0xe9, 0xf2, 0xe8, 0x0c, 0x98, 0xbc, 0x2e, 0x8f, 0xce, 0xa0, 0x5b, + 0x43, 0xef, 0x72, 0xee, 0xab, 0x70, 0x25, 0x94, 0x7b, 0x3d, 0x60, 0x0f, 0x1b, 0x11, 0x47, 0xa9, + 0x74, 0x6a, 0x2b, 0x37, 0x9f, 0xed, 0xa7, 0x94, 0xbd, 0xfd, 0x94, 0xf2, 0x62, 0x3f, 0xa5, 0x7c, + 0x76, 0x90, 0x4a, 0xec, 0x1d, 0xa4, 0x12, 0xbf, 0x1f, 0xa4, 0x12, 0x0f, 0x46, 0x8f, 0xda, 0x31, + 0x9e, 0xee, 0x91, 0x97, 0x90, 0x3b, 0xb2, 0xf5, 0x3e, 0xfe, 0x6f, 0xa5, 0xfc, 0xff, 0x01, 0x00, + 0x00, 0xff, 0xff, 0x18, 0xf5, 0xc3, 0x1b, 0x60, 0x13, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -1316,7 +1315,7 @@ func NewQueryClient(cc grpc1.ClientConn) QueryClient { func (c *queryClient) LiquidValidators(ctx context.Context, in *QueryLiquidValidatorsRequest, opts ...grpc.CallOption) (*QueryLiquidValidatorsResponse, error) { out := new(QueryLiquidValidatorsResponse) - err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Query/LiquidValidators", in, out, opts...) + err := c.cc.Invoke(ctx, "/gaia.liquid.v1beta1.Query/LiquidValidators", in, out, opts...) if err != nil { return nil, err } @@ -1325,7 +1324,7 @@ func (c *queryClient) LiquidValidators(ctx context.Context, in *QueryLiquidValid func (c *queryClient) LiquidValidator(ctx context.Context, in *QueryLiquidValidatorRequest, opts ...grpc.CallOption) (*QueryLiquidValidatorResponse, error) { out := new(QueryLiquidValidatorResponse) - err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Query/LiquidValidator", in, out, opts...) + err := c.cc.Invoke(ctx, "/gaia.liquid.v1beta1.Query/LiquidValidator", in, out, opts...) if err != nil { return nil, err } @@ -1334,7 +1333,7 @@ func (c *queryClient) LiquidValidator(ctx context.Context, in *QueryLiquidValida func (c *queryClient) TokenizeShareRecordById(ctx context.Context, in *QueryTokenizeShareRecordByIdRequest, opts ...grpc.CallOption) (*QueryTokenizeShareRecordByIdResponse, error) { out := new(QueryTokenizeShareRecordByIdResponse) - err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Query/TokenizeShareRecordById", in, out, opts...) + err := c.cc.Invoke(ctx, "/gaia.liquid.v1beta1.Query/TokenizeShareRecordById", in, out, opts...) if err != nil { return nil, err } @@ -1343,7 +1342,7 @@ func (c *queryClient) TokenizeShareRecordById(ctx context.Context, in *QueryToke func (c *queryClient) TokenizeShareRecordByDenom(ctx context.Context, in *QueryTokenizeShareRecordByDenomRequest, opts ...grpc.CallOption) (*QueryTokenizeShareRecordByDenomResponse, error) { out := new(QueryTokenizeShareRecordByDenomResponse) - err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Query/TokenizeShareRecordByDenom", in, out, opts...) + err := c.cc.Invoke(ctx, "/gaia.liquid.v1beta1.Query/TokenizeShareRecordByDenom", in, out, opts...) if err != nil { return nil, err } @@ -1352,7 +1351,7 @@ func (c *queryClient) TokenizeShareRecordByDenom(ctx context.Context, in *QueryT func (c *queryClient) TokenizeShareRecordsOwned(ctx context.Context, in *QueryTokenizeShareRecordsOwnedRequest, opts ...grpc.CallOption) (*QueryTokenizeShareRecordsOwnedResponse, error) { out := new(QueryTokenizeShareRecordsOwnedResponse) - err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Query/TokenizeShareRecordsOwned", in, out, opts...) + err := c.cc.Invoke(ctx, "/gaia.liquid.v1beta1.Query/TokenizeShareRecordsOwned", in, out, opts...) if err != nil { return nil, err } @@ -1361,7 +1360,7 @@ func (c *queryClient) TokenizeShareRecordsOwned(ctx context.Context, in *QueryTo func (c *queryClient) AllTokenizeShareRecords(ctx context.Context, in *QueryAllTokenizeShareRecordsRequest, opts ...grpc.CallOption) (*QueryAllTokenizeShareRecordsResponse, error) { out := new(QueryAllTokenizeShareRecordsResponse) - err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Query/AllTokenizeShareRecords", in, out, opts...) + err := c.cc.Invoke(ctx, "/gaia.liquid.v1beta1.Query/AllTokenizeShareRecords", in, out, opts...) if err != nil { return nil, err } @@ -1370,7 +1369,7 @@ func (c *queryClient) AllTokenizeShareRecords(ctx context.Context, in *QueryAllT func (c *queryClient) LastTokenizeShareRecordId(ctx context.Context, in *QueryLastTokenizeShareRecordIdRequest, opts ...grpc.CallOption) (*QueryLastTokenizeShareRecordIdResponse, error) { out := new(QueryLastTokenizeShareRecordIdResponse) - err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Query/LastTokenizeShareRecordId", in, out, opts...) + err := c.cc.Invoke(ctx, "/gaia.liquid.v1beta1.Query/LastTokenizeShareRecordId", in, out, opts...) if err != nil { return nil, err } @@ -1379,7 +1378,7 @@ func (c *queryClient) LastTokenizeShareRecordId(ctx context.Context, in *QueryLa func (c *queryClient) TotalTokenizeSharedAssets(ctx context.Context, in *QueryTotalTokenizeSharedAssetsRequest, opts ...grpc.CallOption) (*QueryTotalTokenizeSharedAssetsResponse, error) { out := new(QueryTotalTokenizeSharedAssetsResponse) - err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Query/TotalTokenizeSharedAssets", in, out, opts...) + err := c.cc.Invoke(ctx, "/gaia.liquid.v1beta1.Query/TotalTokenizeSharedAssets", in, out, opts...) if err != nil { return nil, err } @@ -1388,7 +1387,7 @@ func (c *queryClient) TotalTokenizeSharedAssets(ctx context.Context, in *QueryTo func (c *queryClient) TotalLiquidStaked(ctx context.Context, in *QueryTotalLiquidStaked, opts ...grpc.CallOption) (*QueryTotalLiquidStakedResponse, error) { out := new(QueryTotalLiquidStakedResponse) - err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Query/TotalLiquidStaked", in, out, opts...) + err := c.cc.Invoke(ctx, "/gaia.liquid.v1beta1.Query/TotalLiquidStaked", in, out, opts...) if err != nil { return nil, err } @@ -1397,7 +1396,7 @@ func (c *queryClient) TotalLiquidStaked(ctx context.Context, in *QueryTotalLiqui func (c *queryClient) TokenizeShareLockInfo(ctx context.Context, in *QueryTokenizeShareLockInfo, opts ...grpc.CallOption) (*QueryTokenizeShareLockInfoResponse, error) { out := new(QueryTokenizeShareLockInfoResponse) - err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Query/TokenizeShareLockInfo", in, out, opts...) + err := c.cc.Invoke(ctx, "/gaia.liquid.v1beta1.Query/TokenizeShareLockInfo", in, out, opts...) if err != nil { return nil, err } @@ -1406,7 +1405,7 @@ func (c *queryClient) TokenizeShareLockInfo(ctx context.Context, in *QueryTokeni func (c *queryClient) Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error) { out := new(QueryParamsResponse) - err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Query/Params", in, out, opts...) + err := c.cc.Invoke(ctx, "/gaia.liquid.v1beta1.Query/Params", in, out, opts...) if err != nil { return nil, err } @@ -1415,7 +1414,7 @@ func (c *queryClient) Params(ctx context.Context, in *QueryParamsRequest, opts . func (c *queryClient) TokenizeShareRecordReward(ctx context.Context, in *QueryTokenizeShareRecordRewardRequest, opts ...grpc.CallOption) (*QueryTokenizeShareRecordRewardResponse, error) { out := new(QueryTokenizeShareRecordRewardResponse) - err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Query/TokenizeShareRecordReward", in, out, opts...) + err := c.cc.Invoke(ctx, "/gaia.liquid.v1beta1.Query/TokenizeShareRecordReward", in, out, opts...) if err != nil { return nil, err } @@ -1509,7 +1508,7 @@ func _Query_LiquidValidators_Handler(srv interface{}, ctx context.Context, dec f } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/kyve.liquid.v1beta1.Query/LiquidValidators", + FullMethod: "/gaia.liquid.v1beta1.Query/LiquidValidators", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(QueryServer).LiquidValidators(ctx, req.(*QueryLiquidValidatorsRequest)) @@ -1527,7 +1526,7 @@ func _Query_LiquidValidator_Handler(srv interface{}, ctx context.Context, dec fu } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/kyve.liquid.v1beta1.Query/LiquidValidator", + FullMethod: "/gaia.liquid.v1beta1.Query/LiquidValidator", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(QueryServer).LiquidValidator(ctx, req.(*QueryLiquidValidatorRequest)) @@ -1545,7 +1544,7 @@ func _Query_TokenizeShareRecordById_Handler(srv interface{}, ctx context.Context } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/kyve.liquid.v1beta1.Query/TokenizeShareRecordById", + FullMethod: "/gaia.liquid.v1beta1.Query/TokenizeShareRecordById", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(QueryServer).TokenizeShareRecordById(ctx, req.(*QueryTokenizeShareRecordByIdRequest)) @@ -1563,7 +1562,7 @@ func _Query_TokenizeShareRecordByDenom_Handler(srv interface{}, ctx context.Cont } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/kyve.liquid.v1beta1.Query/TokenizeShareRecordByDenom", + FullMethod: "/gaia.liquid.v1beta1.Query/TokenizeShareRecordByDenom", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(QueryServer).TokenizeShareRecordByDenom(ctx, req.(*QueryTokenizeShareRecordByDenomRequest)) @@ -1581,7 +1580,7 @@ func _Query_TokenizeShareRecordsOwned_Handler(srv interface{}, ctx context.Conte } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/kyve.liquid.v1beta1.Query/TokenizeShareRecordsOwned", + FullMethod: "/gaia.liquid.v1beta1.Query/TokenizeShareRecordsOwned", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(QueryServer).TokenizeShareRecordsOwned(ctx, req.(*QueryTokenizeShareRecordsOwnedRequest)) @@ -1599,7 +1598,7 @@ func _Query_AllTokenizeShareRecords_Handler(srv interface{}, ctx context.Context } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/kyve.liquid.v1beta1.Query/AllTokenizeShareRecords", + FullMethod: "/gaia.liquid.v1beta1.Query/AllTokenizeShareRecords", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(QueryServer).AllTokenizeShareRecords(ctx, req.(*QueryAllTokenizeShareRecordsRequest)) @@ -1617,7 +1616,7 @@ func _Query_LastTokenizeShareRecordId_Handler(srv interface{}, ctx context.Conte } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/kyve.liquid.v1beta1.Query/LastTokenizeShareRecordId", + FullMethod: "/gaia.liquid.v1beta1.Query/LastTokenizeShareRecordId", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(QueryServer).LastTokenizeShareRecordId(ctx, req.(*QueryLastTokenizeShareRecordIdRequest)) @@ -1635,7 +1634,7 @@ func _Query_TotalTokenizeSharedAssets_Handler(srv interface{}, ctx context.Conte } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/kyve.liquid.v1beta1.Query/TotalTokenizeSharedAssets", + FullMethod: "/gaia.liquid.v1beta1.Query/TotalTokenizeSharedAssets", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(QueryServer).TotalTokenizeSharedAssets(ctx, req.(*QueryTotalTokenizeSharedAssetsRequest)) @@ -1653,7 +1652,7 @@ func _Query_TotalLiquidStaked_Handler(srv interface{}, ctx context.Context, dec } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/kyve.liquid.v1beta1.Query/TotalLiquidStaked", + FullMethod: "/gaia.liquid.v1beta1.Query/TotalLiquidStaked", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(QueryServer).TotalLiquidStaked(ctx, req.(*QueryTotalLiquidStaked)) @@ -1671,7 +1670,7 @@ func _Query_TokenizeShareLockInfo_Handler(srv interface{}, ctx context.Context, } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/kyve.liquid.v1beta1.Query/TokenizeShareLockInfo", + FullMethod: "/gaia.liquid.v1beta1.Query/TokenizeShareLockInfo", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(QueryServer).TokenizeShareLockInfo(ctx, req.(*QueryTokenizeShareLockInfo)) @@ -1689,7 +1688,7 @@ func _Query_Params_Handler(srv interface{}, ctx context.Context, dec func(interf } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/kyve.liquid.v1beta1.Query/Params", + FullMethod: "/gaia.liquid.v1beta1.Query/Params", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(QueryServer).Params(ctx, req.(*QueryParamsRequest)) @@ -1707,7 +1706,7 @@ func _Query_TokenizeShareRecordReward_Handler(srv interface{}, ctx context.Conte } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/kyve.liquid.v1beta1.Query/TokenizeShareRecordReward", + FullMethod: "/gaia.liquid.v1beta1.Query/TokenizeShareRecordReward", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(QueryServer).TokenizeShareRecordReward(ctx, req.(*QueryTokenizeShareRecordRewardRequest)) @@ -1717,7 +1716,7 @@ func _Query_TokenizeShareRecordReward_Handler(srv interface{}, ctx context.Conte var Query_serviceDesc = _Query_serviceDesc var _Query_serviceDesc = grpc.ServiceDesc{ - ServiceName: "kyve.liquid.v1beta1.Query", + ServiceName: "gaia.liquid.v1beta1.Query", HandlerType: (*QueryServer)(nil), Methods: []grpc.MethodDesc{ { @@ -1770,7 +1769,7 @@ var _Query_serviceDesc = grpc.ServiceDesc{ }, }, Streams: []grpc.StreamDesc{}, - Metadata: "kyve/liquid/v1beta1/query.proto", + Metadata: "gaia/liquid/v1beta1/query.proto", } func (m *QueryLiquidValidatorRequest) Marshal() (dAtA []byte, err error) { diff --git a/x/liquid/types/query.pb.gw.go b/x/liquid/types/query.pb.gw.go index 41b6ec20..b371995e 100644 --- a/x/liquid/types/query.pb.gw.go +++ b/x/liquid/types/query.pb.gw.go @@ -1,5 +1,5 @@ // Code generated by protoc-gen-grpc-gateway. DO NOT EDIT. -// source: kyve/liquid/v1beta1/query.proto +// source: gaia/liquid/v1beta1/query.proto /* Package types is a reverse proxy. @@ -1068,29 +1068,29 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie } var ( - pattern_Query_LiquidValidators_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gaia", "liquid", "v1beta1", "liquid_validators"}, "", runtime.AssumeColonVerbOpt(true))) + pattern_Query_LiquidValidators_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gaia", "liquid", "v1beta1", "liquid_validators"}, "", runtime.AssumeColonVerbOpt(false))) - pattern_Query_LiquidValidator_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"gaia", "liquid", "v1beta1", "liquid_validator", "validator_addr"}, "", runtime.AssumeColonVerbOpt(true))) + pattern_Query_LiquidValidator_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"gaia", "liquid", "v1beta1", "liquid_validator", "validator_addr"}, "", runtime.AssumeColonVerbOpt(false))) - pattern_Query_TokenizeShareRecordById_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"gaia", "liquid", "v1beta1", "tokenize_share_record_by_id", "id"}, "", runtime.AssumeColonVerbOpt(true))) + pattern_Query_TokenizeShareRecordById_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"gaia", "liquid", "v1beta1", "tokenize_share_record_by_id", "id"}, "", runtime.AssumeColonVerbOpt(false))) - pattern_Query_TokenizeShareRecordByDenom_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"gaia", "liquid", "v1beta1", "tokenize_share_record_by_denom", "denom"}, "", runtime.AssumeColonVerbOpt(true))) + pattern_Query_TokenizeShareRecordByDenom_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"gaia", "liquid", "v1beta1", "tokenize_share_record_by_denom", "denom"}, "", runtime.AssumeColonVerbOpt(false))) - pattern_Query_TokenizeShareRecordsOwned_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"gaia", "liquid", "v1beta1", "tokenize_share_record_owned", "owner"}, "", runtime.AssumeColonVerbOpt(true))) + pattern_Query_TokenizeShareRecordsOwned_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"gaia", "liquid", "v1beta1", "tokenize_share_record_owned", "owner"}, "", runtime.AssumeColonVerbOpt(false))) - pattern_Query_AllTokenizeShareRecords_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gaia", "liquid", "v1beta1", "tokenize_share_records"}, "", runtime.AssumeColonVerbOpt(true))) + pattern_Query_AllTokenizeShareRecords_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gaia", "liquid", "v1beta1", "tokenize_share_records"}, "", runtime.AssumeColonVerbOpt(false))) - pattern_Query_LastTokenizeShareRecordId_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gaia", "liquid", "v1beta1", "last_tokenize_share_record_id"}, "", runtime.AssumeColonVerbOpt(true))) + pattern_Query_LastTokenizeShareRecordId_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gaia", "liquid", "v1beta1", "last_tokenize_share_record_id"}, "", runtime.AssumeColonVerbOpt(false))) - pattern_Query_TotalTokenizeSharedAssets_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gaia", "liquid", "v1beta1", "total_tokenize_shared_assets"}, "", runtime.AssumeColonVerbOpt(true))) + pattern_Query_TotalTokenizeSharedAssets_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gaia", "liquid", "v1beta1", "total_tokenize_shared_assets"}, "", runtime.AssumeColonVerbOpt(false))) - pattern_Query_TotalLiquidStaked_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gaia", "liquid", "v1beta1", "total_liquid_staked"}, "", runtime.AssumeColonVerbOpt(true))) + pattern_Query_TotalLiquidStaked_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gaia", "liquid", "v1beta1", "total_liquid_staked"}, "", runtime.AssumeColonVerbOpt(false))) - pattern_Query_TokenizeShareLockInfo_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"gaia", "liquid", "v1beta1", "tokenize_share_lock_info", "address"}, "", runtime.AssumeColonVerbOpt(true))) + pattern_Query_TokenizeShareLockInfo_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"gaia", "liquid", "v1beta1", "tokenize_share_lock_info", "address"}, "", runtime.AssumeColonVerbOpt(false))) - pattern_Query_Params_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gaia", "liquid", "v1beta1", "params"}, "", runtime.AssumeColonVerbOpt(true))) + pattern_Query_Params_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gaia", "liquid", "v1beta1", "params"}, "", runtime.AssumeColonVerbOpt(false))) - pattern_Query_TokenizeShareRecordReward_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 2, 4}, []string{"gaia", "liquid", "v1beta1", "owner_address", "tokenize_share_record_rewards"}, "", runtime.AssumeColonVerbOpt(true))) + pattern_Query_TokenizeShareRecordReward_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 2, 4}, []string{"gaia", "liquid", "v1beta1", "owner_address", "tokenize_share_record_rewards"}, "", runtime.AssumeColonVerbOpt(false))) ) var ( diff --git a/x/liquid/types/tx.pb.go b/x/liquid/types/tx.pb.go index 65f23e58..5581f756 100644 --- a/x/liquid/types/tx.pb.go +++ b/x/liquid/types/tx.pb.go @@ -1,5 +1,5 @@ // Code generated by protoc-gen-gogo. DO NOT EDIT. -// source: kyve/liquid/v1beta1/tx.proto +// source: gaia/liquid/v1beta1/tx.proto package types @@ -51,7 +51,7 @@ func (m *MsgUpdateParams) Reset() { *m = MsgUpdateParams{} } func (m *MsgUpdateParams) String() string { return proto.CompactTextString(m) } func (*MsgUpdateParams) ProtoMessage() {} func (*MsgUpdateParams) Descriptor() ([]byte, []int) { - return fileDescriptor_a63931950704005e, []int{0} + return fileDescriptor_e504a27354d32365, []int{0} } func (m *MsgUpdateParams) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -103,7 +103,7 @@ func (m *MsgUpdateParamsResponse) Reset() { *m = MsgUpdateParamsResponse func (m *MsgUpdateParamsResponse) String() string { return proto.CompactTextString(m) } func (*MsgUpdateParamsResponse) ProtoMessage() {} func (*MsgUpdateParamsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_a63931950704005e, []int{1} + return fileDescriptor_e504a27354d32365, []int{1} } func (m *MsgUpdateParamsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -144,7 +144,7 @@ func (m *MsgTokenizeShares) Reset() { *m = MsgTokenizeShares{} } func (m *MsgTokenizeShares) String() string { return proto.CompactTextString(m) } func (*MsgTokenizeShares) ProtoMessage() {} func (*MsgTokenizeShares) Descriptor() ([]byte, []int) { - return fileDescriptor_a63931950704005e, []int{2} + return fileDescriptor_e504a27354d32365, []int{2} } func (m *MsgTokenizeShares) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -182,7 +182,7 @@ func (m *MsgTokenizeSharesResponse) Reset() { *m = MsgTokenizeSharesResp func (m *MsgTokenizeSharesResponse) String() string { return proto.CompactTextString(m) } func (*MsgTokenizeSharesResponse) ProtoMessage() {} func (*MsgTokenizeSharesResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_a63931950704005e, []int{3} + return fileDescriptor_e504a27354d32365, []int{3} } func (m *MsgTokenizeSharesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -229,7 +229,7 @@ func (m *MsgRedeemTokensForShares) Reset() { *m = MsgRedeemTokensForShar func (m *MsgRedeemTokensForShares) String() string { return proto.CompactTextString(m) } func (*MsgRedeemTokensForShares) ProtoMessage() {} func (*MsgRedeemTokensForShares) Descriptor() ([]byte, []int) { - return fileDescriptor_a63931950704005e, []int{4} + return fileDescriptor_e504a27354d32365, []int{4} } func (m *MsgRedeemTokensForShares) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -268,7 +268,7 @@ func (m *MsgRedeemTokensForSharesResponse) Reset() { *m = MsgRedeemToken func (m *MsgRedeemTokensForSharesResponse) String() string { return proto.CompactTextString(m) } func (*MsgRedeemTokensForSharesResponse) ProtoMessage() {} func (*MsgRedeemTokensForSharesResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_a63931950704005e, []int{5} + return fileDescriptor_e504a27354d32365, []int{5} } func (m *MsgRedeemTokensForSharesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -315,7 +315,7 @@ func (m *MsgTransferTokenizeShareRecord) Reset() { *m = MsgTransferToken func (m *MsgTransferTokenizeShareRecord) String() string { return proto.CompactTextString(m) } func (*MsgTransferTokenizeShareRecord) ProtoMessage() {} func (*MsgTransferTokenizeShareRecord) Descriptor() ([]byte, []int) { - return fileDescriptor_a63931950704005e, []int{6} + return fileDescriptor_e504a27354d32365, []int{6} } func (m *MsgTransferTokenizeShareRecord) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -355,7 +355,7 @@ func (m *MsgTransferTokenizeShareRecordResponse) Reset() { func (m *MsgTransferTokenizeShareRecordResponse) String() string { return proto.CompactTextString(m) } func (*MsgTransferTokenizeShareRecordResponse) ProtoMessage() {} func (*MsgTransferTokenizeShareRecordResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_a63931950704005e, []int{7} + return fileDescriptor_e504a27354d32365, []int{7} } func (m *MsgTransferTokenizeShareRecordResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -394,7 +394,7 @@ func (m *MsgDisableTokenizeShares) Reset() { *m = MsgDisableTokenizeShar func (m *MsgDisableTokenizeShares) String() string { return proto.CompactTextString(m) } func (*MsgDisableTokenizeShares) ProtoMessage() {} func (*MsgDisableTokenizeShares) Descriptor() ([]byte, []int) { - return fileDescriptor_a63931950704005e, []int{8} + return fileDescriptor_e504a27354d32365, []int{8} } func (m *MsgDisableTokenizeShares) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -432,7 +432,7 @@ func (m *MsgDisableTokenizeSharesResponse) Reset() { *m = MsgDisableToke func (m *MsgDisableTokenizeSharesResponse) String() string { return proto.CompactTextString(m) } func (*MsgDisableTokenizeSharesResponse) ProtoMessage() {} func (*MsgDisableTokenizeSharesResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_a63931950704005e, []int{9} + return fileDescriptor_e504a27354d32365, []int{9} } func (m *MsgDisableTokenizeSharesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -470,7 +470,7 @@ func (m *MsgEnableTokenizeShares) Reset() { *m = MsgEnableTokenizeShares func (m *MsgEnableTokenizeShares) String() string { return proto.CompactTextString(m) } func (*MsgEnableTokenizeShares) ProtoMessage() {} func (*MsgEnableTokenizeShares) Descriptor() ([]byte, []int) { - return fileDescriptor_a63931950704005e, []int{10} + return fileDescriptor_e504a27354d32365, []int{10} } func (m *MsgEnableTokenizeShares) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -509,7 +509,7 @@ func (m *MsgEnableTokenizeSharesResponse) Reset() { *m = MsgEnableTokeni func (m *MsgEnableTokenizeSharesResponse) String() string { return proto.CompactTextString(m) } func (*MsgEnableTokenizeSharesResponse) ProtoMessage() {} func (*MsgEnableTokenizeSharesResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_a63931950704005e, []int{11} + return fileDescriptor_e504a27354d32365, []int{11} } func (m *MsgEnableTokenizeSharesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -556,7 +556,7 @@ func (m *MsgWithdrawTokenizeShareRecordReward) Reset() { *m = MsgWithdra func (m *MsgWithdrawTokenizeShareRecordReward) String() string { return proto.CompactTextString(m) } func (*MsgWithdrawTokenizeShareRecordReward) ProtoMessage() {} func (*MsgWithdrawTokenizeShareRecordReward) Descriptor() ([]byte, []int) { - return fileDescriptor_a63931950704005e, []int{12} + return fileDescriptor_e504a27354d32365, []int{12} } func (m *MsgWithdrawTokenizeShareRecordReward) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -598,7 +598,7 @@ func (m *MsgWithdrawTokenizeShareRecordRewardResponse) String() string { } func (*MsgWithdrawTokenizeShareRecordRewardResponse) ProtoMessage() {} func (*MsgWithdrawTokenizeShareRecordRewardResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_a63931950704005e, []int{13} + return fileDescriptor_e504a27354d32365, []int{13} } func (m *MsgWithdrawTokenizeShareRecordRewardResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -639,7 +639,7 @@ func (m *MsgWithdrawAllTokenizeShareRecordReward) Reset() { func (m *MsgWithdrawAllTokenizeShareRecordReward) String() string { return proto.CompactTextString(m) } func (*MsgWithdrawAllTokenizeShareRecordReward) ProtoMessage() {} func (*MsgWithdrawAllTokenizeShareRecordReward) Descriptor() ([]byte, []int) { - return fileDescriptor_a63931950704005e, []int{14} + return fileDescriptor_e504a27354d32365, []int{14} } func (m *MsgWithdrawAllTokenizeShareRecordReward) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -681,7 +681,7 @@ func (m *MsgWithdrawAllTokenizeShareRecordRewardResponse) String() string { } func (*MsgWithdrawAllTokenizeShareRecordRewardResponse) ProtoMessage() {} func (*MsgWithdrawAllTokenizeShareRecordRewardResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_a63931950704005e, []int{15} + return fileDescriptor_e504a27354d32365, []int{15} } func (m *MsgWithdrawAllTokenizeShareRecordRewardResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -711,94 +711,93 @@ func (m *MsgWithdrawAllTokenizeShareRecordRewardResponse) XXX_DiscardUnknown() { var xxx_messageInfo_MsgWithdrawAllTokenizeShareRecordRewardResponse proto.InternalMessageInfo func init() { - proto.RegisterType((*MsgUpdateParams)(nil), "kyve.liquid.v1beta1.MsgUpdateParams") - proto.RegisterType((*MsgUpdateParamsResponse)(nil), "kyve.liquid.v1beta1.MsgUpdateParamsResponse") - proto.RegisterType((*MsgTokenizeShares)(nil), "kyve.liquid.v1beta1.MsgTokenizeShares") - proto.RegisterType((*MsgTokenizeSharesResponse)(nil), "kyve.liquid.v1beta1.MsgTokenizeSharesResponse") - proto.RegisterType((*MsgRedeemTokensForShares)(nil), "kyve.liquid.v1beta1.MsgRedeemTokensForShares") - proto.RegisterType((*MsgRedeemTokensForSharesResponse)(nil), "kyve.liquid.v1beta1.MsgRedeemTokensForSharesResponse") - proto.RegisterType((*MsgTransferTokenizeShareRecord)(nil), "kyve.liquid.v1beta1.MsgTransferTokenizeShareRecord") - proto.RegisterType((*MsgTransferTokenizeShareRecordResponse)(nil), "kyve.liquid.v1beta1.MsgTransferTokenizeShareRecordResponse") - proto.RegisterType((*MsgDisableTokenizeShares)(nil), "kyve.liquid.v1beta1.MsgDisableTokenizeShares") - proto.RegisterType((*MsgDisableTokenizeSharesResponse)(nil), "kyve.liquid.v1beta1.MsgDisableTokenizeSharesResponse") - proto.RegisterType((*MsgEnableTokenizeShares)(nil), "kyve.liquid.v1beta1.MsgEnableTokenizeShares") - proto.RegisterType((*MsgEnableTokenizeSharesResponse)(nil), "kyve.liquid.v1beta1.MsgEnableTokenizeSharesResponse") - proto.RegisterType((*MsgWithdrawTokenizeShareRecordReward)(nil), "kyve.liquid.v1beta1.MsgWithdrawTokenizeShareRecordReward") - proto.RegisterType((*MsgWithdrawTokenizeShareRecordRewardResponse)(nil), "kyve.liquid.v1beta1.MsgWithdrawTokenizeShareRecordRewardResponse") - proto.RegisterType((*MsgWithdrawAllTokenizeShareRecordReward)(nil), "kyve.liquid.v1beta1.MsgWithdrawAllTokenizeShareRecordReward") - proto.RegisterType((*MsgWithdrawAllTokenizeShareRecordRewardResponse)(nil), "kyve.liquid.v1beta1.MsgWithdrawAllTokenizeShareRecordRewardResponse") -} - -func init() { proto.RegisterFile("kyve/liquid/v1beta1/tx.proto", fileDescriptor_a63931950704005e) } - -var fileDescriptor_a63931950704005e = []byte{ - // 1044 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x57, 0x4d, 0x6f, 0x1b, 0x45, - 0x18, 0xf6, 0x24, 0x21, 0x8a, 0x87, 0xd2, 0x36, 0xdb, 0xb4, 0xdd, 0xac, 0x83, 0x1d, 0x96, 0xa8, - 0x84, 0x90, 0xee, 0x2a, 0x29, 0x50, 0xd5, 0xe5, 0x2b, 0xa6, 0x41, 0x54, 0x95, 0x01, 0x6d, 0x03, - 0x08, 0x38, 0x58, 0x63, 0xef, 0x74, 0xbd, 0xca, 0xee, 0x8e, 0x99, 0x59, 0xc7, 0x4d, 0x25, 0x24, - 0xc4, 0x09, 0x71, 0xa1, 0x3f, 0xa1, 0x1c, 0x10, 0x88, 0x53, 0x0e, 0x20, 0xc4, 0x3f, 0xa8, 0x04, - 0x87, 0xc2, 0x89, 0x53, 0xa8, 0x92, 0x43, 0x38, 0xf7, 0x17, 0xa0, 0xd9, 0x9d, 0x5d, 0x7f, 0xed, - 0xfa, 0xa3, 0x25, 0x97, 0xc4, 0x33, 0xef, 0xf3, 0xbe, 0xf3, 0x3e, 0xcf, 0x3c, 0x33, 0x63, 0xc3, - 0x85, 0xed, 0xdd, 0x1d, 0xac, 0x3b, 0xf6, 0xe7, 0x4d, 0xdb, 0xd4, 0x77, 0xd6, 0xaa, 0xd8, 0x47, - 0x6b, 0xba, 0x7f, 0x5b, 0x6b, 0x50, 0xe2, 0x13, 0xe9, 0x0c, 0x8f, 0x6a, 0x61, 0x54, 0x13, 0x51, - 0xa5, 0x60, 0x11, 0x62, 0x39, 0x58, 0x0f, 0x20, 0xd5, 0xe6, 0x2d, 0xdd, 0xb7, 0x5d, 0xcc, 0x7c, - 0xe4, 0x36, 0xc2, 0x2c, 0x65, 0xce, 0x22, 0x16, 0x09, 0x3e, 0xea, 0xfc, 0x93, 0x98, 0x9d, 0xaf, - 0x11, 0xe6, 0x12, 0x56, 0x09, 0x03, 0xe1, 0x40, 0x84, 0xf2, 0xe1, 0x48, 0xaf, 0x22, 0x86, 0xe3, - 0x26, 0x6a, 0xc4, 0xf6, 0x44, 0x7c, 0x31, 0xa9, 0x49, 0xd1, 0x55, 0x88, 0x38, 0x2f, 0x2a, 0xb8, - 0xcc, 0xd2, 0x77, 0xd6, 0xf8, 0x3f, 0x11, 0x98, 0x45, 0xae, 0xed, 0x11, 0x3d, 0xf8, 0x1b, 0x4e, - 0xa9, 0xbf, 0x01, 0x78, 0xaa, 0xcc, 0xac, 0x0f, 0x1b, 0x26, 0xf2, 0xf1, 0x07, 0x88, 0x22, 0x97, - 0x49, 0xaf, 0xc2, 0x2c, 0x6a, 0xfa, 0x75, 0x42, 0x6d, 0x7f, 0x57, 0x06, 0x8b, 0x60, 0x39, 0x5b, - 0x92, 0xff, 0xfa, 0xf9, 0xe2, 0x9c, 0x68, 0x73, 0xc3, 0x34, 0x29, 0x66, 0xec, 0xa6, 0x4f, 0x6d, - 0xcf, 0x32, 0xda, 0x50, 0xe9, 0x0d, 0x38, 0xdd, 0x08, 0x2a, 0xc8, 0x13, 0x8b, 0x60, 0xf9, 0xe9, - 0xf5, 0x9c, 0x96, 0xa0, 0x98, 0x16, 0x2e, 0x52, 0xca, 0xde, 0xdf, 0x2f, 0x64, 0x7e, 0x3c, 0xda, - 0x5b, 0x01, 0x86, 0xc8, 0x2a, 0x6a, 0x5f, 0x1d, 0xed, 0xad, 0xb4, 0xeb, 0x7d, 0x73, 0xb4, 0xb7, - 0x92, 0xb3, 0x90, 0x8d, 0x22, 0xb2, 0x3d, 0x7d, 0xaa, 0xf3, 0xf0, 0x7c, 0xcf, 0x94, 0x81, 0x59, - 0x83, 0x78, 0x0c, 0xab, 0x7f, 0x4e, 0xc0, 0xd9, 0x32, 0xb3, 0xb6, 0xc8, 0x36, 0xf6, 0xec, 0x3b, - 0xf8, 0x66, 0x1d, 0x51, 0xcc, 0xa4, 0xeb, 0x70, 0xd6, 0xc4, 0x0e, 0xb6, 0x90, 0x4f, 0x68, 0x05, - 0x85, 0x34, 0x04, 0xc1, 0x85, 0x47, 0xfb, 0x05, 0x79, 0x17, 0xb9, 0x4e, 0x51, 0xed, 0x83, 0xa8, - 0xc6, 0xe9, 0x78, 0x4e, 0x90, 0xe7, 0xa5, 0x76, 0x90, 0x63, 0x9b, 0x5d, 0xa5, 0x26, 0x7a, 0x4b, - 0xf5, 0x41, 0x54, 0xe3, 0x74, 0x3c, 0x17, 0x95, 0xba, 0x0c, 0xa7, 0x91, 0x4b, 0x9a, 0x9e, 0x2f, - 0x4f, 0x06, 0xb2, 0xcd, 0x6b, 0x42, 0x68, 0xee, 0x80, 0x58, 0xb6, 0xb7, 0x89, 0xed, 0x95, 0xa6, - 0xb8, 0x68, 0x86, 0x80, 0x4b, 0xeb, 0xf0, 0xac, 0x2f, 0x08, 0x9a, 0x15, 0xc6, 0x29, 0x56, 0x48, - 0xcb, 0xc3, 0x54, 0x9e, 0xe2, 0x7d, 0x18, 0x67, 0xe2, 0x60, 0x40, 0xff, 0x7d, 0x1e, 0x2a, 0x5e, - 0xf9, 0xfa, 0x5e, 0x21, 0xf3, 0xef, 0xbd, 0x42, 0x86, 0x6b, 0xdd, 0xaf, 0x06, 0xd7, 0xfc, 0x5c, - 0xa0, 0x79, 0x9f, 0x7a, 0xea, 0x16, 0x9c, 0xef, 0x9b, 0x8c, 0x04, 0xef, 0x20, 0x01, 0xc6, 0x22, - 0xa1, 0x3e, 0x04, 0x50, 0x2e, 0x33, 0xcb, 0xc0, 0x26, 0xc6, 0x6e, 0x50, 0x9c, 0xbd, 0x43, 0xe8, - 0xff, 0xbf, 0x61, 0xed, 0x06, 0x27, 0xc6, 0x6a, 0xb0, 0xf8, 0xd6, 0x70, 0xc5, 0x9e, 0x8d, 0x14, - 0x4b, 0x64, 0xa1, 0x7e, 0x06, 0x17, 0xd3, 0x62, 0x4f, 0xae, 0xdf, 0xef, 0x00, 0xe6, 0xf9, 0xb6, - 0x50, 0xe4, 0xb1, 0x5b, 0x98, 0x76, 0x6d, 0x8f, 0x81, 0x6b, 0x84, 0x9a, 0xd2, 0x65, 0x28, 0x47, - 0x56, 0x10, 0x36, 0xa1, 0x41, 0xa0, 0x62, 0x9b, 0xc1, 0x6a, 0x53, 0x46, 0xec, 0xa3, 0x8e, 0xb4, - 0xeb, 0xa6, 0x74, 0x0e, 0x4e, 0x33, 0xec, 0x99, 0x98, 0x86, 0xce, 0x36, 0xc4, 0x48, 0xca, 0xc1, - 0xac, 0x87, 0x5b, 0xc2, 0x6c, 0x93, 0x41, 0x68, 0xc6, 0xc3, 0xad, 0xd0, 0x61, 0x57, 0x3b, 0xf5, - 0x12, 0x19, 0x5c, 0xa4, 0xe7, 0x63, 0x5b, 0xa5, 0xb7, 0xaa, 0x2e, 0xc3, 0x0b, 0x83, 0x11, 0xf1, - 0x09, 0xff, 0x21, 0xf4, 0xcd, 0x35, 0x9b, 0xa1, 0xaa, 0x83, 0x8f, 0xed, 0xa0, 0x8f, 0xb5, 0xfd, - 0x89, 0xcd, 0xa8, 0x6a, 0xb0, 0xfd, 0x89, 0xb1, 0x98, 0xcd, 0xf7, 0x20, 0xb8, 0xcb, 0x36, 0xbd, - 0xe3, 0x25, 0xf3, 0xe6, 0x70, 0x32, 0x0b, 0x11, 0x99, 0xa4, 0x5e, 0xd4, 0x06, 0x2c, 0xa4, 0x84, - 0x62, 0x27, 0x97, 0xe1, 0xa9, 0x1a, 0x71, 0x1b, 0x0e, 0xf6, 0x6d, 0xe2, 0x55, 0xf8, 0x73, 0x28, - 0x2c, 0xad, 0x68, 0xe1, 0x5b, 0xa9, 0x45, 0x6f, 0xa5, 0xb6, 0x15, 0xbd, 0x95, 0xa5, 0x19, 0xee, - 0xe9, 0xbb, 0xff, 0x14, 0x80, 0x71, 0xb2, 0x9d, 0xcc, 0xc3, 0xea, 0x1f, 0x00, 0x2e, 0x95, 0x99, - 0xf5, 0xb1, 0xed, 0xd7, 0x4d, 0x8a, 0x5a, 0x89, 0x96, 0x68, 0x21, 0x6a, 0x4a, 0xaf, 0xc3, 0x67, - 0x02, 0x43, 0xf6, 0x48, 0x24, 0x3f, 0xda, 0x2f, 0xcc, 0x85, 0x12, 0x75, 0x85, 0x55, 0xe3, 0x44, - 0x30, 0x8e, 0xee, 0x87, 0x1c, 0xcc, 0xb6, 0x4f, 0xc5, 0x44, 0x70, 0x2a, 0x66, 0xa8, 0x38, 0x08, - 0xc5, 0x77, 0x3b, 0x75, 0xeb, 0x5e, 0x86, 0x6b, 0xf6, 0x62, 0xa4, 0xd9, 0xd0, 0x2e, 0x55, 0x0d, - 0xae, 0x8e, 0x82, 0x8b, 0x8d, 0xf1, 0x0b, 0x80, 0x2f, 0x74, 0x24, 0x6c, 0x38, 0xce, 0x71, 0x29, - 0x50, 0xbc, 0x31, 0x98, 0xe4, 0x6a, 0x2f, 0xc9, 0x41, 0xbd, 0xa8, 0x6b, 0x70, 0x54, 0x68, 0x44, - 0x75, 0xfd, 0xd7, 0x19, 0x38, 0x59, 0x66, 0x96, 0x54, 0x85, 0x27, 0xba, 0xbe, 0x8e, 0x2c, 0x25, - 0x7e, 0x8d, 0xe8, 0x79, 0xf9, 0x95, 0xd5, 0x51, 0x50, 0xb1, 0x49, 0xeb, 0xf0, 0x64, 0xcf, 0x29, - 0xbb, 0x90, 0x96, 0xdf, 0x8d, 0x53, 0xb4, 0xd1, 0x70, 0xf1, 0x4a, 0x5f, 0xc0, 0xb3, 0xc9, 0x6f, - 0xdb, 0xc5, 0xb4, 0x42, 0x89, 0x70, 0xe5, 0x95, 0xb1, 0xe0, 0xf1, 0xf2, 0xdf, 0x02, 0x98, 0x1b, - 0xf4, 0x36, 0x5c, 0x4a, 0xa5, 0x93, 0x9e, 0xa4, 0x5c, 0x7d, 0x8c, 0xa4, 0x4e, 0x41, 0x92, 0x2f, - 0xed, 0x54, 0x41, 0x12, 0xe1, 0xe9, 0x82, 0x0c, 0xbc, 0x69, 0xa5, 0x3b, 0x70, 0x2e, 0xf1, 0x96, - 0x4d, 0xf5, 0x4f, 0x12, 0x5a, 0x79, 0x79, 0x1c, 0x74, 0xbc, 0xf6, 0x77, 0x00, 0x3e, 0x37, 0xfc, - 0x22, 0xbb, 0x92, 0x56, 0x7b, 0x68, 0xaa, 0xb2, 0xf1, 0xd8, 0xa9, 0x71, 0x8f, 0x3f, 0x01, 0xb8, - 0x34, 0xd2, 0x6d, 0xf3, 0xda, 0xb0, 0xb5, 0x06, 0x65, 0x2b, 0xd7, 0x9e, 0x24, 0x3b, 0x6a, 0x56, - 0x79, 0xea, 0x4b, 0xfe, 0x03, 0xa2, 0xb4, 0x79, 0xff, 0x20, 0x0f, 0x1e, 0x1c, 0xe4, 0xc1, 0xc3, - 0x83, 0x3c, 0xb8, 0x7b, 0x98, 0xcf, 0x3c, 0x38, 0xcc, 0x67, 0xfe, 0x3e, 0xcc, 0x67, 0x3e, 0x7d, - 0xc9, 0xb2, 0xfd, 0x7a, 0xb3, 0xaa, 0xd5, 0x88, 0xab, 0xdf, 0xf8, 0xe4, 0xa3, 0xcd, 0xf7, 0xb0, - 0xdf, 0x22, 0x74, 0x5b, 0xaf, 0xd5, 0x91, 0xed, 0xe9, 0xb7, 0xa3, 0x5f, 0x16, 0xfe, 0x6e, 0x03, - 0xb3, 0xea, 0x74, 0xf0, 0x30, 0x5d, 0xfa, 0x2f, 0x00, 0x00, 0xff, 0xff, 0x86, 0xfd, 0x02, 0xf2, - 0x07, 0x0e, 0x00, 0x00, + proto.RegisterType((*MsgUpdateParams)(nil), "gaia.liquid.v1beta1.MsgUpdateParams") + proto.RegisterType((*MsgUpdateParamsResponse)(nil), "gaia.liquid.v1beta1.MsgUpdateParamsResponse") + proto.RegisterType((*MsgTokenizeShares)(nil), "gaia.liquid.v1beta1.MsgTokenizeShares") + proto.RegisterType((*MsgTokenizeSharesResponse)(nil), "gaia.liquid.v1beta1.MsgTokenizeSharesResponse") + proto.RegisterType((*MsgRedeemTokensForShares)(nil), "gaia.liquid.v1beta1.MsgRedeemTokensForShares") + proto.RegisterType((*MsgRedeemTokensForSharesResponse)(nil), "gaia.liquid.v1beta1.MsgRedeemTokensForSharesResponse") + proto.RegisterType((*MsgTransferTokenizeShareRecord)(nil), "gaia.liquid.v1beta1.MsgTransferTokenizeShareRecord") + proto.RegisterType((*MsgTransferTokenizeShareRecordResponse)(nil), "gaia.liquid.v1beta1.MsgTransferTokenizeShareRecordResponse") + proto.RegisterType((*MsgDisableTokenizeShares)(nil), "gaia.liquid.v1beta1.MsgDisableTokenizeShares") + proto.RegisterType((*MsgDisableTokenizeSharesResponse)(nil), "gaia.liquid.v1beta1.MsgDisableTokenizeSharesResponse") + proto.RegisterType((*MsgEnableTokenizeShares)(nil), "gaia.liquid.v1beta1.MsgEnableTokenizeShares") + proto.RegisterType((*MsgEnableTokenizeSharesResponse)(nil), "gaia.liquid.v1beta1.MsgEnableTokenizeSharesResponse") + proto.RegisterType((*MsgWithdrawTokenizeShareRecordReward)(nil), "gaia.liquid.v1beta1.MsgWithdrawTokenizeShareRecordReward") + proto.RegisterType((*MsgWithdrawTokenizeShareRecordRewardResponse)(nil), "gaia.liquid.v1beta1.MsgWithdrawTokenizeShareRecordRewardResponse") + proto.RegisterType((*MsgWithdrawAllTokenizeShareRecordReward)(nil), "gaia.liquid.v1beta1.MsgWithdrawAllTokenizeShareRecordReward") + proto.RegisterType((*MsgWithdrawAllTokenizeShareRecordRewardResponse)(nil), "gaia.liquid.v1beta1.MsgWithdrawAllTokenizeShareRecordRewardResponse") +} + +func init() { proto.RegisterFile("gaia/liquid/v1beta1/tx.proto", fileDescriptor_e504a27354d32365) } + +var fileDescriptor_e504a27354d32365 = []byte{ + // 1030 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x57, 0x4d, 0x6f, 0xdc, 0x44, + 0x18, 0xde, 0xd9, 0x84, 0x28, 0x3b, 0x94, 0xb6, 0x71, 0xd3, 0xd6, 0xf1, 0x86, 0xdd, 0x60, 0x42, + 0x09, 0x51, 0x6a, 0x6b, 0x53, 0xa0, 0xea, 0x16, 0x28, 0x59, 0x0a, 0xa2, 0x42, 0x2b, 0x90, 0x1b, + 0x84, 0x04, 0x87, 0xd5, 0xec, 0x7a, 0xea, 0xb5, 0xb0, 0x3d, 0x8b, 0xc7, 0x9b, 0x6d, 0x2a, 0x21, + 0x21, 0x4e, 0x88, 0x0b, 0xfd, 0x09, 0xe5, 0x80, 0x40, 0x9c, 0x72, 0x00, 0x21, 0xfe, 0x41, 0x25, + 0x38, 0x14, 0x4e, 0x9c, 0x42, 0x95, 0x1c, 0xc2, 0xb9, 0xbf, 0x00, 0xcd, 0x78, 0xec, 0xfd, 0xb2, + 0xf7, 0xa3, 0x6d, 0x2e, 0xc9, 0x7a, 0xde, 0xe7, 0x7d, 0xe7, 0x7d, 0x9e, 0x79, 0x66, 0xc6, 0x86, + 0xcb, 0x16, 0xb2, 0x91, 0xee, 0xd8, 0x5f, 0xb4, 0x6d, 0x53, 0xdf, 0x29, 0xd5, 0x71, 0x80, 0x4a, + 0x7a, 0x70, 0x5b, 0x6b, 0xf9, 0x24, 0x20, 0xd2, 0x19, 0x16, 0xd5, 0xc2, 0xa8, 0x26, 0xa2, 0x4a, + 0xd1, 0x22, 0xc4, 0x72, 0xb0, 0xce, 0x21, 0xf5, 0xf6, 0x2d, 0x3d, 0xb0, 0x5d, 0x4c, 0x03, 0xe4, + 0xb6, 0xc2, 0x2c, 0x65, 0xd1, 0x22, 0x16, 0xe1, 0x3f, 0x75, 0xf6, 0x4b, 0x8c, 0x2e, 0x35, 0x08, + 0x75, 0x09, 0xad, 0x85, 0x81, 0xf0, 0x41, 0x84, 0x0a, 0xe1, 0x93, 0x5e, 0x47, 0x14, 0xc7, 0x4d, + 0x34, 0x88, 0xed, 0x89, 0xf8, 0x4a, 0x52, 0x93, 0xa2, 0xab, 0x10, 0x71, 0x5e, 0x54, 0x70, 0xa9, + 0xa5, 0xef, 0x94, 0xd8, 0x3f, 0x11, 0x58, 0x40, 0xae, 0xed, 0x11, 0x9d, 0xff, 0x0d, 0x87, 0xd4, + 0xdf, 0x01, 0x3c, 0x55, 0xa5, 0xd6, 0xc7, 0x2d, 0x13, 0x05, 0xf8, 0x23, 0xe4, 0x23, 0x97, 0x4a, + 0xaf, 0xc3, 0x1c, 0x6a, 0x07, 0x4d, 0xe2, 0xdb, 0xc1, 0xae, 0x0c, 0x56, 0xc0, 0x5a, 0xae, 0x22, + 0xff, 0xfd, 0xcb, 0xc5, 0x45, 0xd1, 0xe6, 0x96, 0x69, 0xfa, 0x98, 0xd2, 0x9b, 0x81, 0x6f, 0x7b, + 0x96, 0xd1, 0x85, 0x4a, 0x6f, 0xc1, 0xb9, 0x16, 0xaf, 0x20, 0x67, 0x57, 0xc0, 0xda, 0xb3, 0x9b, + 0x79, 0x2d, 0x41, 0x31, 0x2d, 0x9c, 0xa4, 0x92, 0xbb, 0xbf, 0x5f, 0xcc, 0xfc, 0x74, 0xb4, 0xb7, + 0x0e, 0x0c, 0x91, 0x55, 0xd6, 0xbe, 0x3e, 0xda, 0x5b, 0xef, 0xd6, 0xfb, 0xf6, 0x68, 0x6f, 0x3d, + 0xdf, 0x4b, 0x76, 0xa0, 0x4f, 0x75, 0x09, 0x9e, 0x1f, 0x18, 0x32, 0x30, 0x6d, 0x11, 0x8f, 0x62, + 0xf5, 0xaf, 0x2c, 0x5c, 0xa8, 0x52, 0x6b, 0x9b, 0x7c, 0x8e, 0x3d, 0xfb, 0x0e, 0xbe, 0xd9, 0x44, + 0x3e, 0xa6, 0xd2, 0x0d, 0xb8, 0x60, 0x62, 0x07, 0x5b, 0x28, 0x20, 0x7e, 0x0d, 0x85, 0x34, 0x04, + 0xc1, 0xe5, 0x47, 0xfb, 0x45, 0x79, 0x17, 0xb9, 0x4e, 0x59, 0x1d, 0x82, 0xa8, 0xc6, 0xe9, 0x78, + 0x4c, 0x90, 0x67, 0xa5, 0x76, 0x90, 0x63, 0x9b, 0x7d, 0xa5, 0xb2, 0x83, 0xa5, 0x86, 0x20, 0xaa, + 0x71, 0x3a, 0x1e, 0x8b, 0x4a, 0x5d, 0x86, 0x73, 0xc8, 0x25, 0x6d, 0x2f, 0x90, 0x67, 0xb8, 0x6c, + 0x4b, 0x9a, 0x10, 0x9a, 0x39, 0x20, 0x96, 0xed, 0x1d, 0x62, 0x7b, 0x95, 0x59, 0x26, 0x9a, 0x21, + 0xe0, 0xd2, 0x26, 0x3c, 0x1b, 0x08, 0x82, 0x66, 0x8d, 0x32, 0x8a, 0x35, 0xd2, 0xf1, 0xb0, 0x2f, + 0xcf, 0xb2, 0x3e, 0x8c, 0x33, 0x71, 0x90, 0xd3, 0xff, 0x90, 0x85, 0xca, 0x57, 0xbe, 0xb9, 0x57, + 0xcc, 0xfc, 0x77, 0xaf, 0x98, 0x61, 0x5a, 0x0f, 0xab, 0xc1, 0x34, 0x3f, 0xc7, 0x35, 0x1f, 0x52, + 0x4f, 0xdd, 0x86, 0x4b, 0x43, 0x83, 0x91, 0xe0, 0x3d, 0x24, 0xc0, 0x54, 0x24, 0xd4, 0x87, 0x00, + 0xca, 0x55, 0x6a, 0x19, 0xd8, 0xc4, 0xd8, 0xe5, 0xc5, 0xe9, 0x7b, 0xc4, 0x7f, 0xfa, 0x0b, 0xd6, + 0x6d, 0x30, 0x3b, 0x55, 0x83, 0xe5, 0xb7, 0xc7, 0x2b, 0xf6, 0x7c, 0xa4, 0x58, 0x22, 0x0b, 0xf5, + 0x33, 0xb8, 0x92, 0x16, 0x7b, 0x72, 0xfd, 0xfe, 0x00, 0xb0, 0xc0, 0x96, 0xc5, 0x47, 0x1e, 0xbd, + 0x85, 0xfd, 0xbe, 0xe5, 0x31, 0x70, 0x83, 0xf8, 0xa6, 0x74, 0x19, 0xca, 0x91, 0x15, 0x84, 0x4d, + 0x7c, 0x1e, 0xa8, 0xd9, 0x26, 0x9f, 0x6d, 0xd6, 0x88, 0x7d, 0xd4, 0x93, 0x76, 0xc3, 0x94, 0xce, + 0xc1, 0x39, 0x8a, 0x3d, 0x13, 0xfb, 0xa1, 0xb3, 0x0d, 0xf1, 0x24, 0xe5, 0x61, 0xce, 0xc3, 0x1d, + 0x61, 0xb6, 0x19, 0x1e, 0x9a, 0xf7, 0x70, 0x27, 0x74, 0xd8, 0xd5, 0x5e, 0xbd, 0x44, 0x06, 0x13, + 0xe9, 0xc5, 0xd8, 0x56, 0xe9, 0xad, 0xaa, 0x6b, 0xf0, 0xc2, 0x68, 0x44, 0xbc, 0xc3, 0x7f, 0x0c, + 0x7d, 0x73, 0xdd, 0xa6, 0xa8, 0xee, 0xe0, 0x63, 0xdb, 0xe8, 0x53, 0x2d, 0x7f, 0x62, 0x33, 0xaa, + 0xca, 0x97, 0x3f, 0x31, 0x16, 0xb3, 0xf9, 0x01, 0xf0, 0xb3, 0xec, 0x5d, 0xef, 0x78, 0xc9, 0x5c, + 0x1b, 0x4f, 0x66, 0x39, 0x22, 0x93, 0xd4, 0x8b, 0xda, 0x82, 0xc5, 0x94, 0x50, 0xec, 0xe4, 0x2a, + 0x3c, 0xd5, 0x20, 0x6e, 0xcb, 0xc1, 0x81, 0x4d, 0xbc, 0x1a, 0xbb, 0x0e, 0x85, 0xa5, 0x15, 0x2d, + 0xbc, 0x2b, 0xb5, 0xe8, 0xae, 0xd4, 0xb6, 0xa3, 0xbb, 0xb2, 0x32, 0xcf, 0x3c, 0x7d, 0xf7, 0xdf, + 0x22, 0x30, 0x4e, 0x76, 0x93, 0x59, 0x58, 0xfd, 0x13, 0xc0, 0xd5, 0x2a, 0xb5, 0x3e, 0xb1, 0x83, + 0xa6, 0xe9, 0xa3, 0x4e, 0xa2, 0x25, 0x3a, 0xc8, 0x37, 0xa5, 0x37, 0xe1, 0x73, 0xdc, 0x90, 0x03, + 0x12, 0xc9, 0x8f, 0xf6, 0x8b, 0x8b, 0xa1, 0x44, 0x7d, 0x61, 0xd5, 0x38, 0xc1, 0x9f, 0xa3, 0xf3, + 0x21, 0x0f, 0x73, 0xdd, 0x5d, 0x91, 0xe5, 0xbb, 0x62, 0xde, 0x17, 0x1b, 0xa1, 0xfc, 0x7e, 0xaf, + 0x6e, 0xfd, 0xd3, 0x30, 0xcd, 0x5e, 0x89, 0x34, 0x1b, 0xdb, 0xa5, 0xaa, 0xc1, 0x8d, 0x49, 0x70, + 0xb1, 0x31, 0x7e, 0x05, 0xf0, 0xe5, 0x9e, 0x84, 0x2d, 0xc7, 0x39, 0x2e, 0x05, 0xca, 0x1f, 0x8c, + 0x26, 0xb9, 0x31, 0x48, 0x72, 0x54, 0x2f, 0x6a, 0x09, 0x4e, 0x0a, 0x8d, 0xa8, 0x6e, 0xfe, 0x36, + 0x0f, 0x67, 0xaa, 0xd4, 0x92, 0xea, 0xf0, 0x44, 0xdf, 0xeb, 0xc8, 0x6a, 0xe2, 0x6b, 0xc4, 0xc0, + 0xcd, 0xaf, 0x6c, 0x4c, 0x82, 0x8a, 0x4d, 0xda, 0x84, 0x27, 0x07, 0x76, 0xd9, 0x85, 0xb4, 0xfc, + 0x7e, 0x9c, 0xa2, 0x4d, 0x86, 0x8b, 0x67, 0xfa, 0x12, 0x9e, 0x4d, 0xbe, 0xdb, 0x2e, 0xa6, 0x15, + 0x4a, 0x84, 0x2b, 0xaf, 0x4d, 0x05, 0x8f, 0xa7, 0xff, 0x0e, 0xc0, 0xfc, 0xa8, 0xbb, 0xe1, 0x52, + 0x2a, 0x9d, 0xf4, 0x24, 0xe5, 0xea, 0x63, 0x24, 0xf5, 0x0a, 0x92, 0x7c, 0x68, 0xa7, 0x0a, 0x92, + 0x08, 0x4f, 0x17, 0x64, 0xe4, 0x49, 0x2b, 0xdd, 0x81, 0x8b, 0x89, 0xa7, 0x6c, 0xaa, 0x7f, 0x92, + 0xd0, 0xca, 0xab, 0xd3, 0xa0, 0xe3, 0xb9, 0xbf, 0x07, 0xf0, 0x85, 0xf1, 0x07, 0xd9, 0x95, 0xb4, + 0xda, 0x63, 0x53, 0x95, 0xad, 0xc7, 0x4e, 0x8d, 0x7b, 0xfc, 0x19, 0xc0, 0xd5, 0x89, 0x4e, 0x9b, + 0x37, 0xc6, 0xcd, 0x35, 0x2a, 0x5b, 0xb9, 0xfe, 0x24, 0xd9, 0x51, 0xb3, 0xca, 0x33, 0x5f, 0xb1, + 0x0f, 0x88, 0xca, 0xb5, 0xfb, 0x07, 0x05, 0xf0, 0xe0, 0xa0, 0x00, 0x1e, 0x1e, 0x14, 0xc0, 0xdd, + 0xc3, 0x42, 0xe6, 0xc1, 0x61, 0x21, 0xf3, 0xcf, 0x61, 0x21, 0xf3, 0xe9, 0x4b, 0x96, 0x1d, 0x34, + 0xdb, 0x75, 0xad, 0x41, 0x5c, 0xf1, 0x95, 0xa5, 0xf3, 0x63, 0xec, 0x76, 0xf4, 0x4d, 0x11, 0xec, + 0xb6, 0x30, 0xad, 0xcf, 0xf1, 0x2b, 0xe9, 0xd2, 0xff, 0x01, 0x00, 0x00, 0xff, 0xff, 0xcc, 0x28, + 0x23, 0xcc, 0x01, 0x0e, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -848,7 +847,7 @@ func NewMsgClient(cc grpc1.ClientConn) MsgClient { func (c *msgClient) UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error) { out := new(MsgUpdateParamsResponse) - err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Msg/UpdateParams", in, out, opts...) + err := c.cc.Invoke(ctx, "/gaia.liquid.v1beta1.Msg/UpdateParams", in, out, opts...) if err != nil { return nil, err } @@ -857,7 +856,7 @@ func (c *msgClient) UpdateParams(ctx context.Context, in *MsgUpdateParams, opts func (c *msgClient) TokenizeShares(ctx context.Context, in *MsgTokenizeShares, opts ...grpc.CallOption) (*MsgTokenizeSharesResponse, error) { out := new(MsgTokenizeSharesResponse) - err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Msg/TokenizeShares", in, out, opts...) + err := c.cc.Invoke(ctx, "/gaia.liquid.v1beta1.Msg/TokenizeShares", in, out, opts...) if err != nil { return nil, err } @@ -866,7 +865,7 @@ func (c *msgClient) TokenizeShares(ctx context.Context, in *MsgTokenizeShares, o func (c *msgClient) RedeemTokensForShares(ctx context.Context, in *MsgRedeemTokensForShares, opts ...grpc.CallOption) (*MsgRedeemTokensForSharesResponse, error) { out := new(MsgRedeemTokensForSharesResponse) - err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Msg/RedeemTokensForShares", in, out, opts...) + err := c.cc.Invoke(ctx, "/gaia.liquid.v1beta1.Msg/RedeemTokensForShares", in, out, opts...) if err != nil { return nil, err } @@ -875,7 +874,7 @@ func (c *msgClient) RedeemTokensForShares(ctx context.Context, in *MsgRedeemToke func (c *msgClient) TransferTokenizeShareRecord(ctx context.Context, in *MsgTransferTokenizeShareRecord, opts ...grpc.CallOption) (*MsgTransferTokenizeShareRecordResponse, error) { out := new(MsgTransferTokenizeShareRecordResponse) - err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Msg/TransferTokenizeShareRecord", in, out, opts...) + err := c.cc.Invoke(ctx, "/gaia.liquid.v1beta1.Msg/TransferTokenizeShareRecord", in, out, opts...) if err != nil { return nil, err } @@ -884,7 +883,7 @@ func (c *msgClient) TransferTokenizeShareRecord(ctx context.Context, in *MsgTran func (c *msgClient) DisableTokenizeShares(ctx context.Context, in *MsgDisableTokenizeShares, opts ...grpc.CallOption) (*MsgDisableTokenizeSharesResponse, error) { out := new(MsgDisableTokenizeSharesResponse) - err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Msg/DisableTokenizeShares", in, out, opts...) + err := c.cc.Invoke(ctx, "/gaia.liquid.v1beta1.Msg/DisableTokenizeShares", in, out, opts...) if err != nil { return nil, err } @@ -893,7 +892,7 @@ func (c *msgClient) DisableTokenizeShares(ctx context.Context, in *MsgDisableTok func (c *msgClient) EnableTokenizeShares(ctx context.Context, in *MsgEnableTokenizeShares, opts ...grpc.CallOption) (*MsgEnableTokenizeSharesResponse, error) { out := new(MsgEnableTokenizeSharesResponse) - err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Msg/EnableTokenizeShares", in, out, opts...) + err := c.cc.Invoke(ctx, "/gaia.liquid.v1beta1.Msg/EnableTokenizeShares", in, out, opts...) if err != nil { return nil, err } @@ -902,7 +901,7 @@ func (c *msgClient) EnableTokenizeShares(ctx context.Context, in *MsgEnableToken func (c *msgClient) WithdrawTokenizeShareRecordReward(ctx context.Context, in *MsgWithdrawTokenizeShareRecordReward, opts ...grpc.CallOption) (*MsgWithdrawTokenizeShareRecordRewardResponse, error) { out := new(MsgWithdrawTokenizeShareRecordRewardResponse) - err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Msg/WithdrawTokenizeShareRecordReward", in, out, opts...) + err := c.cc.Invoke(ctx, "/gaia.liquid.v1beta1.Msg/WithdrawTokenizeShareRecordReward", in, out, opts...) if err != nil { return nil, err } @@ -911,7 +910,7 @@ func (c *msgClient) WithdrawTokenizeShareRecordReward(ctx context.Context, in *M func (c *msgClient) WithdrawAllTokenizeShareRecordReward(ctx context.Context, in *MsgWithdrawAllTokenizeShareRecordReward, opts ...grpc.CallOption) (*MsgWithdrawAllTokenizeShareRecordRewardResponse, error) { out := new(MsgWithdrawAllTokenizeShareRecordRewardResponse) - err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Msg/WithdrawAllTokenizeShareRecordReward", in, out, opts...) + err := c.cc.Invoke(ctx, "/gaia.liquid.v1beta1.Msg/WithdrawAllTokenizeShareRecordReward", in, out, opts...) if err != nil { return nil, err } @@ -988,7 +987,7 @@ func _Msg_UpdateParams_Handler(srv interface{}, ctx context.Context, dec func(in } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/kyve.liquid.v1beta1.Msg/UpdateParams", + FullMethod: "/gaia.liquid.v1beta1.Msg/UpdateParams", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(MsgServer).UpdateParams(ctx, req.(*MsgUpdateParams)) @@ -1006,7 +1005,7 @@ func _Msg_TokenizeShares_Handler(srv interface{}, ctx context.Context, dec func( } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/kyve.liquid.v1beta1.Msg/TokenizeShares", + FullMethod: "/gaia.liquid.v1beta1.Msg/TokenizeShares", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(MsgServer).TokenizeShares(ctx, req.(*MsgTokenizeShares)) @@ -1024,7 +1023,7 @@ func _Msg_RedeemTokensForShares_Handler(srv interface{}, ctx context.Context, de } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/kyve.liquid.v1beta1.Msg/RedeemTokensForShares", + FullMethod: "/gaia.liquid.v1beta1.Msg/RedeemTokensForShares", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(MsgServer).RedeemTokensForShares(ctx, req.(*MsgRedeemTokensForShares)) @@ -1042,7 +1041,7 @@ func _Msg_TransferTokenizeShareRecord_Handler(srv interface{}, ctx context.Conte } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/kyve.liquid.v1beta1.Msg/TransferTokenizeShareRecord", + FullMethod: "/gaia.liquid.v1beta1.Msg/TransferTokenizeShareRecord", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(MsgServer).TransferTokenizeShareRecord(ctx, req.(*MsgTransferTokenizeShareRecord)) @@ -1060,7 +1059,7 @@ func _Msg_DisableTokenizeShares_Handler(srv interface{}, ctx context.Context, de } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/kyve.liquid.v1beta1.Msg/DisableTokenizeShares", + FullMethod: "/gaia.liquid.v1beta1.Msg/DisableTokenizeShares", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(MsgServer).DisableTokenizeShares(ctx, req.(*MsgDisableTokenizeShares)) @@ -1078,7 +1077,7 @@ func _Msg_EnableTokenizeShares_Handler(srv interface{}, ctx context.Context, dec } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/kyve.liquid.v1beta1.Msg/EnableTokenizeShares", + FullMethod: "/gaia.liquid.v1beta1.Msg/EnableTokenizeShares", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(MsgServer).EnableTokenizeShares(ctx, req.(*MsgEnableTokenizeShares)) @@ -1096,7 +1095,7 @@ func _Msg_WithdrawTokenizeShareRecordReward_Handler(srv interface{}, ctx context } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/kyve.liquid.v1beta1.Msg/WithdrawTokenizeShareRecordReward", + FullMethod: "/gaia.liquid.v1beta1.Msg/WithdrawTokenizeShareRecordReward", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(MsgServer).WithdrawTokenizeShareRecordReward(ctx, req.(*MsgWithdrawTokenizeShareRecordReward)) @@ -1114,7 +1113,7 @@ func _Msg_WithdrawAllTokenizeShareRecordReward_Handler(srv interface{}, ctx cont } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/kyve.liquid.v1beta1.Msg/WithdrawAllTokenizeShareRecordReward", + FullMethod: "/gaia.liquid.v1beta1.Msg/WithdrawAllTokenizeShareRecordReward", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(MsgServer).WithdrawAllTokenizeShareRecordReward(ctx, req.(*MsgWithdrawAllTokenizeShareRecordReward)) @@ -1124,7 +1123,7 @@ func _Msg_WithdrawAllTokenizeShareRecordReward_Handler(srv interface{}, ctx cont var Msg_serviceDesc = _Msg_serviceDesc var _Msg_serviceDesc = grpc.ServiceDesc{ - ServiceName: "kyve.liquid.v1beta1.Msg", + ServiceName: "gaia.liquid.v1beta1.Msg", HandlerType: (*MsgServer)(nil), Methods: []grpc.MethodDesc{ { @@ -1161,7 +1160,7 @@ var _Msg_serviceDesc = grpc.ServiceDesc{ }, }, Streams: []grpc.StreamDesc{}, - Metadata: "kyve/liquid/v1beta1/tx.proto", + Metadata: "gaia/liquid/v1beta1/tx.proto", } func (m *MsgUpdateParams) Marshal() (dAtA []byte, err error) { From ebcf8fd8d6d1bd7f87c40b277299d4ce0a7595ed Mon Sep 17 00:00:00 2001 From: mbreithecker Date: Wed, 30 Jul 2025 14:06:16 +0200 Subject: [PATCH 3/8] chore: proto --- proto/kyve/delegation/v1beta1/tx.proto | 7 +- proto/kyve/liquid/module/v1/module.proto | 4 +- proto/kyve/liquid/v1beta1/genesis.proto | 20 +- proto/kyve/liquid/v1beta1/liquid.proto | 15 +- proto/kyve/liquid/v1beta1/query.proto | 129 +++++---- proto/kyve/liquid/v1beta1/tx.proto | 75 +++--- x/liquid/module.go | 6 +- x/liquid/types/genesis.pb.go | 87 +++--- x/liquid/types/liquid.pb.go | 127 ++++----- x/liquid/types/query.pb.go | 329 ++++++++++++----------- x/liquid/types/query.pb.gw.go | 26 +- x/liquid/types/tx.pb.go | 245 ++++++++--------- 12 files changed, 531 insertions(+), 539 deletions(-) diff --git a/proto/kyve/delegation/v1beta1/tx.proto b/proto/kyve/delegation/v1beta1/tx.proto index bceca101..6c5f509d 100644 --- a/proto/kyve/delegation/v1beta1/tx.proto +++ b/proto/kyve/delegation/v1beta1/tx.proto @@ -8,12 +8,11 @@ import "cosmos_proto/cosmos.proto"; option go_package = "github.com/KYVENetwork/chain/x/stakers/types_delegation_v1beta1"; /* - NOTICE: - This file needs to be kept for backwards compatibility with the governance module. - Otherwise, it is not possible to decode legacy delegation param update proposals. + NOTICE: + This file needs to be kept for backwards compatibility with the governance module. + Otherwise, it is not possible to decode legacy delegation param update proposals. */ - // Msg defines the Msg service. service Msg { option (cosmos.msg.v1.service) = true; diff --git a/proto/kyve/liquid/module/v1/module.proto b/proto/kyve/liquid/module/v1/module.proto index fa10a2cb..46693964 100644 --- a/proto/kyve/liquid/module/v1/module.proto +++ b/proto/kyve/liquid/module/v1/module.proto @@ -10,9 +10,7 @@ import "cosmos/app/v1alpha1/module.proto"; // Module is the config object of the liquid module. message Module { - option (cosmos.app.v1alpha1.module) = { - go_import : "github.com/KYVENetwork/chain/x/liquid" - }; + option (cosmos.app.v1alpha1.module) = {go_import: "github.com/KYVENetwork/chain/x/liquid"}; // authority defines the custom module authority. If not set, defaults to the // governance module. diff --git a/proto/kyve/liquid/v1beta1/genesis.proto b/proto/kyve/liquid/v1beta1/genesis.proto index 859ed24d..acb86a2f 100644 --- a/proto/kyve/liquid/v1beta1/genesis.proto +++ b/proto/kyve/liquid/v1beta1/genesis.proto @@ -5,22 +5,23 @@ syntax = "proto3"; package kyve.liquid.v1beta1; -option go_package = "github.com/KYVENetwork/chain/x/liquid/types"; - -import "gogoproto/gogo.proto"; -import "kyve/liquid/v1beta1/liquid.proto"; import "amino/amino.proto"; +import "gogoproto/gogo.proto"; import "google/protobuf/timestamp.proto"; +import "kyve/liquid/v1beta1/liquid.proto"; + +option go_package = "github.com/KYVENetwork/chain/x/liquid/types"; // GenesisState defines the liquid module's genesis state. message GenesisState { // params defines all the parameters of related to deposit. - Params params = 1 - [ (gogoproto.nullable) = false, (amino.dont_omitempty) = true ]; + Params params = 1 [ + (gogoproto.nullable) = false, + (amino.dont_omitempty) = true + ]; // store tokenize share records to provide reward to record owners - repeated TokenizeShareRecord tokenize_share_records = 9 - [ (gogoproto.nullable) = false ]; + repeated TokenizeShareRecord tokenize_share_records = 9 [(gogoproto.nullable) = false]; // last tokenize share record id, used for next share record id calculation uint64 last_tokenize_share_record_id = 10; @@ -33,8 +34,7 @@ message GenesisState { ]; // tokenize shares locks at genesis - repeated TokenizeShareLock tokenize_share_locks = 12 - [ (gogoproto.nullable) = false ]; + repeated TokenizeShareLock tokenize_share_locks = 12 [(gogoproto.nullable) = false]; } // TokenizeSharesLock required for specifying account locks at genesis diff --git a/proto/kyve/liquid/v1beta1/liquid.proto b/proto/kyve/liquid/v1beta1/liquid.proto index 034b97ae..beb49ab2 100644 --- a/proto/kyve/liquid/v1beta1/liquid.proto +++ b/proto/kyve/liquid/v1beta1/liquid.proto @@ -5,11 +5,10 @@ syntax = "proto3"; package kyve.liquid.v1beta1; -import "gogoproto/gogo.proto"; - import "amino/amino.proto"; import "cosmos/base/v1beta1/coin.proto"; import "cosmos_proto/cosmos.proto"; +import "gogoproto/gogo.proto"; option go_package = "github.com/KYVENetwork/chain/x/liquid/types"; @@ -45,13 +44,14 @@ message TokenizeShareRecord { uint64 id = 1; string owner = 2; string module_account = 3; // module account take the role of delegator - string validator = - 4; // validator delegated to for tokenize share record creation + string validator = 4; // validator delegated to for tokenize share record creation } // PendingTokenizeShareAuthorizations stores a list of addresses that have their // tokenize share enablement in progress -message PendingTokenizeShareAuthorizations { repeated string addresses = 1; } +message PendingTokenizeShareAuthorizations { + repeated string addresses = 1; +} // TokenizeShareLockStatus indicates whether the address is able to tokenize // shares @@ -90,8 +90,7 @@ message LiquidValidator { // operator_address defines the address of the validator's operator; bech // encoded in JSON. - string operator_address = 1 - [ (cosmos_proto.scalar) = "cosmos.AddressString" ]; + string operator_address = 1 [(cosmos_proto.scalar) = "cosmos.AddressString"]; // Number of shares either tokenized or owned by a liquid staking provider string liquid_shares = 3 [ @@ -99,4 +98,4 @@ message LiquidValidator { (gogoproto.customtype) = "cosmossdk.io/math.LegacyDec", (gogoproto.nullable) = false ]; -} \ No newline at end of file +} diff --git a/proto/kyve/liquid/v1beta1/query.proto b/proto/kyve/liquid/v1beta1/query.proto index 7c6527e3..67606d9c 100644 --- a/proto/kyve/liquid/v1beta1/query.proto +++ b/proto/kyve/liquid/v1beta1/query.proto @@ -5,13 +5,13 @@ syntax = "proto3"; package kyve.liquid.v1beta1; +import "amino/amino.proto"; import "cosmos/base/query/v1beta1/pagination.proto"; +import "cosmos/base/v1beta1/coin.proto"; +import "cosmos/query/v1/query.proto"; import "gogoproto/gogo.proto"; import "google/api/annotations.proto"; import "kyve/liquid/v1beta1/liquid.proto"; -import "cosmos/base/v1beta1/coin.proto"; -import "cosmos/query/v1/query.proto"; -import "amino/amino.proto"; option go_package = "github.com/KYVENetwork/chain/x/liquid/types"; @@ -21,73 +21,55 @@ service Query { // // When called from another module, this query might consume a high amount of // gas if the pagination field is incorrectly set. - rpc LiquidValidators(QueryLiquidValidatorsRequest) - returns (QueryLiquidValidatorsResponse) { + rpc LiquidValidators(QueryLiquidValidatorsRequest) returns (QueryLiquidValidatorsResponse) { option (cosmos.query.v1.module_query_safe) = true; option (google.api.http).get = "/gaia/liquid/v1beta1/liquid_validators"; } // Query for an individual liquid validator by validator address - rpc LiquidValidator(QueryLiquidValidatorRequest) - returns (QueryLiquidValidatorResponse) { - option (google.api.http).get = - "/gaia/liquid/v1beta1/liquid_validator/{validator_addr}"; + rpc LiquidValidator(QueryLiquidValidatorRequest) returns (QueryLiquidValidatorResponse) { + option (google.api.http).get = "/gaia/liquid/v1beta1/liquid_validator/{validator_addr}"; } // Query for individual tokenize share record information by share by id - rpc TokenizeShareRecordById(QueryTokenizeShareRecordByIdRequest) - returns (QueryTokenizeShareRecordByIdResponse) { - option (google.api.http).get = - "/gaia/liquid/v1beta1/tokenize_share_record_by_id/{id}"; + rpc TokenizeShareRecordById(QueryTokenizeShareRecordByIdRequest) returns (QueryTokenizeShareRecordByIdResponse) { + option (google.api.http).get = "/gaia/liquid/v1beta1/tokenize_share_record_by_id/{id}"; } // Query for individual tokenize share record information by share denom - rpc TokenizeShareRecordByDenom(QueryTokenizeShareRecordByDenomRequest) - returns (QueryTokenizeShareRecordByDenomResponse) { - option (google.api.http).get = - "/gaia/liquid/v1beta1/tokenize_share_record_by_denom/{denom}"; + rpc TokenizeShareRecordByDenom(QueryTokenizeShareRecordByDenomRequest) returns (QueryTokenizeShareRecordByDenomResponse) { + option (google.api.http).get = "/gaia/liquid/v1beta1/tokenize_share_record_by_denom/{denom}"; } // Query tokenize share records by address - rpc TokenizeShareRecordsOwned(QueryTokenizeShareRecordsOwnedRequest) - returns (QueryTokenizeShareRecordsOwnedResponse) { - option (google.api.http).get = - "/gaia/liquid/v1beta1/tokenize_share_record_owned/{owner}"; + rpc TokenizeShareRecordsOwned(QueryTokenizeShareRecordsOwnedRequest) returns (QueryTokenizeShareRecordsOwnedResponse) { + option (google.api.http).get = "/gaia/liquid/v1beta1/tokenize_share_record_owned/{owner}"; } // Query for all tokenize share records - rpc AllTokenizeShareRecords(QueryAllTokenizeShareRecordsRequest) - returns (QueryAllTokenizeShareRecordsResponse) { - option (google.api.http).get = - "/gaia/liquid/v1beta1/tokenize_share_records"; + rpc AllTokenizeShareRecords(QueryAllTokenizeShareRecordsRequest) returns (QueryAllTokenizeShareRecordsResponse) { + option (google.api.http).get = "/gaia/liquid/v1beta1/tokenize_share_records"; } // Query for last tokenize share record id - rpc LastTokenizeShareRecordId(QueryLastTokenizeShareRecordIdRequest) - returns (QueryLastTokenizeShareRecordIdResponse) { - option (google.api.http).get = - "/gaia/liquid/v1beta1/last_tokenize_share_record_id"; + rpc LastTokenizeShareRecordId(QueryLastTokenizeShareRecordIdRequest) returns (QueryLastTokenizeShareRecordIdResponse) { + option (google.api.http).get = "/gaia/liquid/v1beta1/last_tokenize_share_record_id"; } // Query for total tokenized staked assets - rpc TotalTokenizeSharedAssets(QueryTotalTokenizeSharedAssetsRequest) - returns (QueryTotalTokenizeSharedAssetsResponse) { - option (google.api.http).get = - "/gaia/liquid/v1beta1/total_tokenize_shared_assets"; + rpc TotalTokenizeSharedAssets(QueryTotalTokenizeSharedAssetsRequest) returns (QueryTotalTokenizeSharedAssetsResponse) { + option (google.api.http).get = "/gaia/liquid/v1beta1/total_tokenize_shared_assets"; } // Query for total liquid staked (including tokenized shares or owned by an // liquid staking provider) - rpc TotalLiquidStaked(QueryTotalLiquidStaked) - returns (QueryTotalLiquidStakedResponse) { + rpc TotalLiquidStaked(QueryTotalLiquidStaked) returns (QueryTotalLiquidStakedResponse) { option (google.api.http).get = "/gaia/liquid/v1beta1/total_liquid_staked"; } // Query tokenize share locks - rpc TokenizeShareLockInfo(QueryTokenizeShareLockInfo) - returns (QueryTokenizeShareLockInfoResponse) { - option (google.api.http).get = - "/gaia/liquid/v1beta1/tokenize_share_lock_info/{address}"; + rpc TokenizeShareLockInfo(QueryTokenizeShareLockInfo) returns (QueryTokenizeShareLockInfoResponse) { + option (google.api.http).get = "/gaia/liquid/v1beta1/tokenize_share_lock_info/{address}"; } // Parameters queries the liquid parameters. @@ -97,22 +79,24 @@ service Query { } // TokenizeShareRecordReward queries the tokenize share record rewards - rpc TokenizeShareRecordReward(QueryTokenizeShareRecordRewardRequest) - returns (QueryTokenizeShareRecordRewardResponse) { - option (google.api.http).get = - "/gaia/liquid/v1beta1/{owner_address}/tokenize_share_record_rewards"; + rpc TokenizeShareRecordReward(QueryTokenizeShareRecordRewardRequest) returns (QueryTokenizeShareRecordRewardResponse) { + option (google.api.http).get = "/gaia/liquid/v1beta1/{owner_address}/tokenize_share_record_rewards"; } } // QueryLiquidValidatorRequest is the request type for the Query/LiquidValidator // RPC method. -message QueryLiquidValidatorRequest { string validator_addr = 1; } +message QueryLiquidValidatorRequest { + string validator_addr = 1; +} // QueryLiquidValidatorResponse is the response type for the // Query/LiquidValidator RPC method. message QueryLiquidValidatorResponse { - LiquidValidator liquid_validator = 1 - [ (gogoproto.nullable) = false, (amino.dont_omitempty) = true ]; + LiquidValidator liquid_validator = 1 [ + (gogoproto.nullable) = false, + (amino.dont_omitempty) = true + ]; } // QueryLiquidValidatorsRequest is request type for the @@ -125,8 +109,10 @@ message QueryLiquidValidatorsRequest { // QueryLiquidValidatorsResponse is response type for the // Query/QueryLiquidValidators RPC method. message QueryLiquidValidatorsResponse { - repeated LiquidValidator liquid_validators = 1 - [ (gogoproto.nullable) = false, (amino.dont_omitempty) = true ]; + repeated LiquidValidator liquid_validators = 1 [ + (gogoproto.nullable) = false, + (amino.dont_omitempty) = true + ]; // pagination defines the pagination in the response. cosmos.base.query.v1beta1.PageResponse pagination = 2; } @@ -137,38 +123,46 @@ message QueryParamsRequest {} // QueryParamsResponse is response type for the Query/Params RPC method. message QueryParamsResponse { // params holds all the parameters of this module. - Params params = 1 - [ (gogoproto.nullable) = false, (amino.dont_omitempty) = true ]; + Params params = 1 [ + (gogoproto.nullable) = false, + (amino.dont_omitempty) = true + ]; } // QueryTokenizeShareRecordByIdRequest is request type for the // Query/QueryTokenizeShareRecordById RPC method. -message QueryTokenizeShareRecordByIdRequest { uint64 id = 1; } +message QueryTokenizeShareRecordByIdRequest { + uint64 id = 1; +} // QueryTokenizeShareRecordByIdRequest is response type for the // Query/QueryTokenizeShareRecordById RPC method. message QueryTokenizeShareRecordByIdResponse { - TokenizeShareRecord record = 1 [ (gogoproto.nullable) = false ]; + TokenizeShareRecord record = 1 [(gogoproto.nullable) = false]; } // QueryTokenizeShareRecordByDenomRequest is request type for the // Query/QueryTokenizeShareRecordByDenom RPC method. -message QueryTokenizeShareRecordByDenomRequest { string denom = 1; } +message QueryTokenizeShareRecordByDenomRequest { + string denom = 1; +} // QueryTokenizeShareRecordByDenomResponse is response type for the // Query/QueryTokenizeShareRecordByDenom RPC method. message QueryTokenizeShareRecordByDenomResponse { - TokenizeShareRecord record = 1 [ (gogoproto.nullable) = false ]; + TokenizeShareRecord record = 1 [(gogoproto.nullable) = false]; } // QueryTokenizeShareRecordsOwnedRequest is request type for the // Query/QueryTokenizeShareRecordsOwned RPC method. -message QueryTokenizeShareRecordsOwnedRequest { string owner = 1; } +message QueryTokenizeShareRecordsOwnedRequest { + string owner = 1; +} // QueryTokenizeShareRecordsOwnedResponse is response type for the // Query/QueryTokenizeShareRecordsOwned RPC method. message QueryTokenizeShareRecordsOwnedResponse { - repeated TokenizeShareRecord records = 1 [ (gogoproto.nullable) = false ]; + repeated TokenizeShareRecord records = 1 [(gogoproto.nullable) = false]; } // QueryAllTokenizeShareRecordsRequest is request type for the @@ -181,7 +175,7 @@ message QueryAllTokenizeShareRecordsRequest { // QueryAllTokenizeShareRecordsResponse is response type for the // Query/QueryAllTokenizeShareRecords RPC method. message QueryAllTokenizeShareRecordsResponse { - repeated TokenizeShareRecord records = 1 [ (gogoproto.nullable) = false ]; + repeated TokenizeShareRecord records = 1 [(gogoproto.nullable) = false]; // pagination defines the pagination in the response. cosmos.base.query.v1beta1.PageResponse pagination = 2; } @@ -192,7 +186,9 @@ message QueryLastTokenizeShareRecordIdRequest {} // QueryLastTokenizeShareRecordIdResponse is response type for the // Query/QueryLastTokenizeShareRecordId RPC method. -message QueryLastTokenizeShareRecordIdResponse { uint64 id = 1; } +message QueryLastTokenizeShareRecordIdResponse { + uint64 id = 1; +} // QueryTotalTokenizeSharedAssetsRequest is request type for the // Query/QueryTotalTokenizeSharedAssets RPC method. @@ -201,7 +197,7 @@ message QueryTotalTokenizeSharedAssetsRequest {} // QueryTotalTokenizeSharedAssetsResponse is response type for the // Query/QueryTotalTokenizeSharedAssets RPC method. message QueryTotalTokenizeSharedAssetsResponse { - cosmos.base.v1beta1.Coin value = 1 [ (gogoproto.nullable) = false ]; + cosmos.base.v1beta1.Coin value = 1 [(gogoproto.nullable) = false]; } // QueryTotalLiquidStakedRequest is request type for the @@ -210,11 +206,15 @@ message QueryTotalLiquidStaked {} // QueryTotalLiquidStakedResponse is response type for the // Query/QueryQueryTotalLiquidStaked RPC method. -message QueryTotalLiquidStakedResponse { string tokens = 1; } +message QueryTotalLiquidStakedResponse { + string tokens = 1; +} // QueryTokenizeShareLockInfo queries the tokenize share lock information // associated with given account -message QueryTokenizeShareLockInfo { string address = 1; } +message QueryTokenizeShareLockInfo { + string address = 1; +} // QueryTokenizeShareLockInfoResponse is the response from the // QueryTokenizeShareLockInfo query @@ -229,18 +229,17 @@ message QueryTokenizeShareRecordRewardRequest { option (gogoproto.equal) = false; option (gogoproto.goproto_getters) = false; - string owner_address = 1 [ (gogoproto.moretags) = "yaml:\"owner_address\"" ]; + string owner_address = 1 [(gogoproto.moretags) = "yaml:\"owner_address\""]; } // QueryTokenizeShareRecordRewardResponse is the response type for the // Query/TokenizeShareRecordReward RPC method. message QueryTokenizeShareRecordRewardResponse { // rewards defines all the rewards accrued by a delegator. - repeated TokenizeShareRecordReward rewards = 1 - [ (gogoproto.nullable) = false ]; + repeated TokenizeShareRecordReward rewards = 1 [(gogoproto.nullable) = false]; // total defines the sum of all the rewards. repeated cosmos.base.v1beta1.DecCoin total = 2 [ (gogoproto.nullable) = false, (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.DecCoins" ]; -} \ No newline at end of file +} diff --git a/proto/kyve/liquid/v1beta1/tx.proto b/proto/kyve/liquid/v1beta1/tx.proto index a107598b..ebdb62bc 100644 --- a/proto/kyve/liquid/v1beta1/tx.proto +++ b/proto/kyve/liquid/v1beta1/tx.proto @@ -5,14 +5,13 @@ syntax = "proto3"; package kyve.liquid.v1beta1; -import "google/protobuf/timestamp.proto"; -import "gogoproto/gogo.proto"; - -import "cosmos_proto/cosmos.proto"; +import "amino/amino.proto"; import "cosmos/base/v1beta1/coin.proto"; -import "kyve/liquid/v1beta1/liquid.proto"; import "cosmos/msg/v1/msg.proto"; -import "amino/amino.proto"; +import "cosmos_proto/cosmos.proto"; +import "gogoproto/gogo.proto"; +import "google/protobuf/timestamp.proto"; +import "kyve/liquid/v1beta1/liquid.proto"; option go_package = "github.com/KYVENetwork/chain/x/liquid/types"; @@ -29,34 +28,27 @@ service Msg { // RedeemTokensForShares defines a method for redeeming tokens from a // validator for shares. - rpc RedeemTokensForShares(MsgRedeemTokensForShares) - returns (MsgRedeemTokensForSharesResponse); + rpc RedeemTokensForShares(MsgRedeemTokensForShares) returns (MsgRedeemTokensForSharesResponse); // TransferTokenizeShareRecord defines a method to transfer ownership of // TokenizeShareRecord - rpc TransferTokenizeShareRecord(MsgTransferTokenizeShareRecord) - returns (MsgTransferTokenizeShareRecordResponse); + rpc TransferTokenizeShareRecord(MsgTransferTokenizeShareRecord) returns (MsgTransferTokenizeShareRecordResponse); // DisableTokenizeShares defines a method to prevent the tokenization of an // addresses stake - rpc DisableTokenizeShares(MsgDisableTokenizeShares) - returns (MsgDisableTokenizeSharesResponse); + rpc DisableTokenizeShares(MsgDisableTokenizeShares) returns (MsgDisableTokenizeSharesResponse); // EnableTokenizeShares defines a method to re-enable the tokenization of an // addresseses stake after it has been disabled - rpc EnableTokenizeShares(MsgEnableTokenizeShares) - returns (MsgEnableTokenizeSharesResponse); + rpc EnableTokenizeShares(MsgEnableTokenizeShares) returns (MsgEnableTokenizeSharesResponse); // WithdrawTokenizeShareRecordReward defines a method to withdraw reward for // an owning TokenizeShareRecord - rpc WithdrawTokenizeShareRecordReward(MsgWithdrawTokenizeShareRecordReward) - returns (MsgWithdrawTokenizeShareRecordRewardResponse); + rpc WithdrawTokenizeShareRecordReward(MsgWithdrawTokenizeShareRecordReward) returns (MsgWithdrawTokenizeShareRecordRewardResponse); // WithdrawAllTokenizeShareRecordReward defines a method to withdraw reward // for all owning TokenizeShareRecord - rpc WithdrawAllTokenizeShareRecordReward( - MsgWithdrawAllTokenizeShareRecordReward) - returns (MsgWithdrawAllTokenizeShareRecordRewardResponse); + rpc WithdrawAllTokenizeShareRecordReward(MsgWithdrawAllTokenizeShareRecordReward) returns (MsgWithdrawAllTokenizeShareRecordRewardResponse); } // MsgUpdateParams is the Msg/UpdateParams request type. @@ -66,17 +58,19 @@ message MsgUpdateParams { // authority is the address that controls the module (defaults to x/gov unless // overwritten). - string authority = 1 [ (cosmos_proto.scalar) = "cosmos.AddressString" ]; + string authority = 1 [(cosmos_proto.scalar) = "cosmos.AddressString"]; // params defines the x/liquid parameters to update. // // NOTE: All parameters must be supplied. - Params params = 2 - [ (gogoproto.nullable) = false, (amino.dont_omitempty) = true ]; -}; + Params params = 2 [ + (gogoproto.nullable) = false, + (amino.dont_omitempty) = true + ]; +} // MsgUpdateParamsResponse defines the response structure for executing a // MsgUpdateParams message. -message MsgUpdateParamsResponse {}; +message MsgUpdateParamsResponse {} // MsgTokenizeShares tokenizes a delegation message MsgTokenizeShares { @@ -86,17 +80,15 @@ message MsgTokenizeShares { option (gogoproto.equal) = false; option (gogoproto.goproto_getters) = false; - string delegator_address = 1 - [ (gogoproto.moretags) = "yaml:\"delegator_address\"" ]; - string validator_address = 2 - [ (gogoproto.moretags) = "yaml:\"validator_address\"" ]; - cosmos.base.v1beta1.Coin amount = 3 [ (gogoproto.nullable) = false ]; + string delegator_address = 1 [(gogoproto.moretags) = "yaml:\"delegator_address\""]; + string validator_address = 2 [(gogoproto.moretags) = "yaml:\"validator_address\""]; + cosmos.base.v1beta1.Coin amount = 3 [(gogoproto.nullable) = false]; string tokenized_share_owner = 4; } // MsgTokenizeSharesResponse defines the Msg/MsgTokenizeShares response type. message MsgTokenizeSharesResponse { - cosmos.base.v1beta1.Coin amount = 1 [ (gogoproto.nullable) = false ]; + cosmos.base.v1beta1.Coin amount = 1 [(gogoproto.nullable) = false]; } // MsgRedeemTokensForShares redeems a tokenized share back into a native @@ -108,15 +100,14 @@ message MsgRedeemTokensForShares { option (gogoproto.equal) = false; option (gogoproto.goproto_getters) = false; - string delegator_address = 1 - [ (gogoproto.moretags) = "yaml:\"delegator_address\"" ]; - cosmos.base.v1beta1.Coin amount = 2 [ (gogoproto.nullable) = false ]; + string delegator_address = 1 [(gogoproto.moretags) = "yaml:\"delegator_address\""]; + cosmos.base.v1beta1.Coin amount = 2 [(gogoproto.nullable) = false]; } // MsgRedeemTokensForSharesResponse defines the Msg/MsgRedeemTokensForShares // response type. message MsgRedeemTokensForSharesResponse { - cosmos.base.v1beta1.Coin amount = 1 [ (gogoproto.nullable) = false ]; + cosmos.base.v1beta1.Coin amount = 1 [(gogoproto.nullable) = false]; } // MsgTransferTokenizeShareRecord transfer a tokenize share record @@ -145,8 +136,7 @@ message MsgDisableTokenizeShares { option (gogoproto.equal) = false; option (gogoproto.goproto_getters) = false; - string delegator_address = 1 - [ (gogoproto.moretags) = "yaml:\"delegator_address\"" ]; + string delegator_address = 1 [(gogoproto.moretags) = "yaml:\"delegator_address\""]; } // MsgDisableTokenizeSharesResponse defines the Msg/DisableTokenizeShares @@ -161,15 +151,16 @@ message MsgEnableTokenizeShares { option (gogoproto.equal) = false; option (gogoproto.goproto_getters) = false; - string delegator_address = 1 - [ (gogoproto.moretags) = "yaml:\"delegator_address\"" ]; + string delegator_address = 1 [(gogoproto.moretags) = "yaml:\"delegator_address\""]; } // MsgEnableTokenizeSharesResponse defines the Msg/EnableTokenizeShares response // type. message MsgEnableTokenizeSharesResponse { - google.protobuf.Timestamp completion_time = 1 - [ (gogoproto.nullable) = false, (gogoproto.stdtime) = true ]; + google.protobuf.Timestamp completion_time = 1 [ + (gogoproto.nullable) = false, + (gogoproto.stdtime) = true + ]; } // MsgWithdrawTokenizeShareRecordReward withdraws tokenize share rewards for a @@ -181,7 +172,7 @@ message MsgWithdrawTokenizeShareRecordReward { option (gogoproto.equal) = false; option (gogoproto.goproto_getters) = false; - string owner_address = 1 [ (gogoproto.moretags) = "yaml:\"owner_address\"" ]; + string owner_address = 1 [(gogoproto.moretags) = "yaml:\"owner_address\""]; uint64 record_id = 2; } @@ -198,7 +189,7 @@ message MsgWithdrawAllTokenizeShareRecordReward { option (gogoproto.equal) = false; option (gogoproto.goproto_getters) = false; - string owner_address = 1 [ (gogoproto.moretags) = "yaml:\"owner_address\"" ]; + string owner_address = 1 [(gogoproto.moretags) = "yaml:\"owner_address\""]; } // MsgWithdrawAllTokenizeShareRecordRewardResponse defines the diff --git a/x/liquid/module.go b/x/liquid/module.go index 0194d459..32f0c7b9 100644 --- a/x/liquid/module.go +++ b/x/liquid/module.go @@ -6,10 +6,12 @@ package liquid import ( "context" - "cosmossdk.io/core/store" - "cosmossdk.io/depinject" "encoding/json" "fmt" + + "cosmossdk.io/core/store" + "cosmossdk.io/depinject" + authKeeper "github.com/cosmos/cosmos-sdk/x/auth/keeper" authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" bankKeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper" diff --git a/x/liquid/types/genesis.pb.go b/x/liquid/types/genesis.pb.go index 4c509112..671b3406 100644 --- a/x/liquid/types/genesis.pb.go +++ b/x/liquid/types/genesis.pb.go @@ -1,5 +1,5 @@ // Code generated by protoc-gen-gogo. DO NOT EDIT. -// source: gaia/liquid/v1beta1/genesis.proto +// source: kyve/liquid/v1beta1/genesis.proto package types @@ -47,7 +47,7 @@ func (m *GenesisState) Reset() { *m = GenesisState{} } func (m *GenesisState) String() string { return proto.CompactTextString(m) } func (*GenesisState) ProtoMessage() {} func (*GenesisState) Descriptor() ([]byte, []int) { - return fileDescriptor_492f6dcc93442fc6, []int{0} + return fileDescriptor_1e0ff895af275f9d, []int{0} } func (m *GenesisState) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -118,7 +118,7 @@ func (m *TokenizeShareLock) Reset() { *m = TokenizeShareLock{} } func (m *TokenizeShareLock) String() string { return proto.CompactTextString(m) } func (*TokenizeShareLock) ProtoMessage() {} func (*TokenizeShareLock) Descriptor() ([]byte, []int) { - return fileDescriptor_492f6dcc93442fc6, []int{1} + return fileDescriptor_1e0ff895af275f9d, []int{1} } func (m *TokenizeShareLock) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -169,46 +169,47 @@ func (m *TokenizeShareLock) GetCompletionTime() time.Time { } func init() { - proto.RegisterType((*GenesisState)(nil), "gaia.liquid.v1beta1.GenesisState") - proto.RegisterType((*TokenizeShareLock)(nil), "gaia.liquid.v1beta1.TokenizeShareLock") -} - -func init() { proto.RegisterFile("gaia/liquid/v1beta1/genesis.proto", fileDescriptor_492f6dcc93442fc6) } - -var fileDescriptor_492f6dcc93442fc6 = []byte{ - // 508 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x53, 0x3f, 0x6f, 0xd3, 0x4e, - 0x18, 0x8e, 0x7f, 0xa9, 0xf2, 0x53, 0x2e, 0x11, 0xa8, 0x26, 0x04, 0x13, 0x84, 0x9d, 0x5a, 0x02, - 0x45, 0x0c, 0x77, 0x6a, 0xd9, 0x18, 0x00, 0x79, 0x41, 0x95, 0x3a, 0x20, 0xa7, 0x13, 0x03, 0xd6, - 0xc5, 0x3e, 0x9c, 0x53, 0xec, 0x5c, 0xf0, 0xfb, 0x06, 0x51, 0x16, 0xbe, 0x42, 0x3f, 0x06, 0x13, - 0xe2, 0x63, 0x74, 0xec, 0x06, 0x62, 0x08, 0x28, 0x19, 0xd8, 0xfb, 0x09, 0x90, 0xef, 0x1c, 0x21, - 0xa5, 0x46, 0x2c, 0x51, 0xde, 0x7b, 0xfe, 0xf8, 0xd1, 0x7b, 0xcf, 0x91, 0x83, 0x94, 0x4b, 0xce, - 0x32, 0xf9, 0x76, 0x29, 0x13, 0xf6, 0xee, 0x70, 0x22, 0x90, 0x1f, 0xb2, 0x54, 0xcc, 0x05, 0x48, - 0xa0, 0x8b, 0x42, 0xa1, 0xb2, 0x6f, 0x95, 0x14, 0x6a, 0x28, 0xb4, 0xa2, 0x0c, 0x7a, 0xa9, 0x4a, - 0x95, 0xc6, 0x59, 0xf9, 0xcf, 0x50, 0x07, 0xc3, 0x3a, 0xb7, 0x4a, 0x69, 0x18, 0xfb, 0x3c, 0x97, - 0x73, 0xc5, 0xf4, 0x6f, 0x75, 0xe4, 0xa5, 0x4a, 0xa5, 0x99, 0x60, 0x7a, 0x9a, 0x2c, 0xdf, 0x30, - 0x94, 0xb9, 0x00, 0xe4, 0xf9, 0xc2, 0x10, 0xfc, 0xaf, 0x4d, 0xd2, 0x7d, 0x61, 0x22, 0x8d, 0x91, - 0xa3, 0xb0, 0x9f, 0x92, 0xd6, 0x82, 0x17, 0x3c, 0x07, 0xc7, 0x1a, 0x5a, 0xa3, 0xce, 0xd1, 0x3d, - 0x5a, 0x13, 0x91, 0xbe, 0xd4, 0x94, 0xa0, 0x7d, 0xb1, 0xf2, 0x1a, 0x9f, 0x7e, 0x7d, 0x79, 0x64, - 0x85, 0x95, 0xca, 0x4e, 0x48, 0x1f, 0xd5, 0x4c, 0xcc, 0xe5, 0x07, 0x11, 0xc1, 0x94, 0x17, 0x22, - 0x2a, 0x44, 0xac, 0x8a, 0x04, 0x9c, 0xf6, 0xb0, 0x39, 0xea, 0x1c, 0x8d, 0x6a, 0xfd, 0x4e, 0x2b, - 0xc9, 0xb8, 0x54, 0x84, 0x5a, 0x10, 0xec, 0x95, 0xe6, 0x61, 0x0f, 0xaf, 0x43, 0x60, 0x3f, 0x27, - 0xf7, 0x33, 0x0e, 0x18, 0xd5, 0x7e, 0x2a, 0x92, 0x89, 0x43, 0x86, 0xd6, 0x68, 0x2f, 0xbc, 0x5b, - 0x92, 0x6a, 0xbc, 0x8f, 0x13, 0xfb, 0x23, 0x19, 0xa0, 0x42, 0x9e, 0x45, 0x26, 0x49, 0x04, 0xc8, - 0x67, 0x22, 0x31, 0x86, 0xe0, 0x74, 0x86, 0xd6, 0xa8, 0x1b, 0x04, 0x65, 0x82, 0xef, 0x2b, 0xef, - 0x76, 0xac, 0x20, 0x57, 0x00, 0xc9, 0x8c, 0x4a, 0xc5, 0x72, 0x8e, 0x53, 0x7a, 0x3c, 0xc7, 0xab, - 0x95, 0x77, 0x70, 0xc6, 0xf3, 0xec, 0x89, 0xff, 0x77, 0x23, 0x3f, 0xbc, 0xa3, 0xc1, 0x13, 0x8d, - 0x8d, 0x35, 0xa4, 0xf3, 0x80, 0xfd, 0x9a, 0xf4, 0x76, 0xd2, 0x67, 0x2a, 0x9e, 0x81, 0xd3, 0xd5, - 0x6b, 0x7a, 0xf8, 0xef, 0x35, 0x9d, 0xa8, 0x78, 0x56, 0x2d, 0xc9, 0xc6, 0x5d, 0x00, 0xfc, 0xcf, - 0x16, 0xd9, 0xbf, 0xc6, 0xb7, 0x1d, 0xf2, 0x3f, 0x4f, 0x92, 0x42, 0x80, 0xb9, 0xdf, 0x76, 0xb8, - 0x1d, 0xed, 0x3e, 0x69, 0x01, 0x72, 0x5c, 0x82, 0xf3, 0x9f, 0x06, 0xaa, 0xc9, 0x4e, 0xc9, 0xcd, - 0x58, 0xe5, 0x8b, 0x4c, 0xa0, 0x54, 0xf3, 0xa8, 0xec, 0x8f, 0xd3, 0xd4, 0xcd, 0x18, 0x50, 0x53, - 0x2e, 0xba, 0x2d, 0x17, 0x3d, 0xdd, 0x96, 0x2b, 0xf0, 0xcb, 0x58, 0x57, 0x2b, 0xaf, 0x6f, 0x16, - 0xb4, 0x63, 0xe0, 0x9f, 0xff, 0xf0, 0xac, 0xf0, 0xc6, 0x9f, 0xd3, 0x52, 0x18, 0x3c, 0xbb, 0x58, - 0xbb, 0xd6, 0xe5, 0xda, 0xb5, 0x7e, 0xae, 0x5d, 0xeb, 0x7c, 0xe3, 0x36, 0x2e, 0x37, 0x6e, 0xe3, - 0xdb, 0xc6, 0x6d, 0xbc, 0x7a, 0x90, 0x4a, 0x9c, 0x2e, 0x27, 0x34, 0x56, 0x39, 0x33, 0x57, 0xc1, - 0xf4, 0x63, 0x78, 0xbf, 0x7d, 0x0e, 0x78, 0xb6, 0x10, 0x30, 0x69, 0xe9, 0x20, 0x8f, 0x7f, 0x07, - 0x00, 0x00, 0xff, 0xff, 0x55, 0xb5, 0xaf, 0x8a, 0x78, 0x03, 0x00, 0x00, + proto.RegisterType((*GenesisState)(nil), "kyve.liquid.v1beta1.GenesisState") + proto.RegisterType((*TokenizeShareLock)(nil), "kyve.liquid.v1beta1.TokenizeShareLock") +} + +func init() { proto.RegisterFile("kyve/liquid/v1beta1/genesis.proto", fileDescriptor_1e0ff895af275f9d) } + +var fileDescriptor_1e0ff895af275f9d = []byte{ + // 518 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x52, 0x4d, 0x8b, 0xd3, 0x40, + 0x18, 0x6e, 0xdc, 0xa5, 0xd2, 0x69, 0x51, 0x76, 0xac, 0x35, 0x56, 0x4c, 0xba, 0x39, 0x48, 0x51, + 0x98, 0x61, 0xd7, 0x9b, 0x07, 0x91, 0xc0, 0x22, 0x8b, 0x8b, 0x48, 0xba, 0x08, 0x7a, 0x30, 0x4c, + 0x93, 0x31, 0x1d, 0xf2, 0x31, 0x35, 0xf3, 0x76, 0xb5, 0x5e, 0xfc, 0x0b, 0xfb, 0x33, 0x3c, 0x89, + 0x3f, 0x63, 0x8f, 0x7b, 0x53, 0x3c, 0x54, 0x69, 0x0f, 0xde, 0xf7, 0x17, 0x48, 0x26, 0x29, 0x42, + 0x37, 0xe2, 0x25, 0xcc, 0x3b, 0xcf, 0xc7, 0x3c, 0xbc, 0x79, 0xd0, 0x6e, 0x3c, 0x3f, 0xe1, 0x34, + 0x11, 0xef, 0x66, 0x22, 0xa4, 0x27, 0x7b, 0x63, 0x0e, 0x6c, 0x8f, 0x46, 0x3c, 0xe3, 0x4a, 0x28, + 0x32, 0xcd, 0x25, 0x48, 0x7c, 0xa3, 0xa0, 0x90, 0x92, 0x42, 0x2a, 0x4a, 0x7f, 0x87, 0xa5, 0x22, + 0x93, 0x54, 0x7f, 0x4b, 0x5e, 0xbf, 0x1b, 0xc9, 0x48, 0xea, 0x23, 0x2d, 0x4e, 0xd5, 0xad, 0x1d, + 0x49, 0x19, 0x25, 0x9c, 0xea, 0x69, 0x3c, 0x7b, 0x4b, 0x41, 0xa4, 0x5c, 0x01, 0x4b, 0xa7, 0x15, + 0x61, 0x50, 0x97, 0xa0, 0x7a, 0x4d, 0x33, 0x9c, 0x6f, 0x5b, 0xa8, 0xf3, 0xb4, 0x8c, 0x34, 0x02, + 0x06, 0x1c, 0x3f, 0x46, 0xcd, 0x29, 0xcb, 0x59, 0xaa, 0x4c, 0x63, 0x60, 0x0c, 0xdb, 0xfb, 0x77, + 0x48, 0x4d, 0x44, 0xf2, 0x42, 0x53, 0xdc, 0xd6, 0xd9, 0xc2, 0x6e, 0x7c, 0xfe, 0xfd, 0xf5, 0xbe, + 0xe1, 0x55, 0x2a, 0x1c, 0xa2, 0x1e, 0xc8, 0x98, 0x67, 0xe2, 0x23, 0xf7, 0xd5, 0x84, 0xe5, 0xdc, + 0xcf, 0x79, 0x20, 0xf3, 0x50, 0x99, 0xad, 0xc1, 0xd6, 0xb0, 0xbd, 0x3f, 0xac, 0xf5, 0x3b, 0xae, + 0x24, 0xa3, 0x42, 0xe1, 0x69, 0x81, 0xbb, 0x5d, 0x98, 0x7b, 0x5d, 0xb8, 0x0c, 0x29, 0xfc, 0x04, + 0xdd, 0x4d, 0x98, 0x02, 0xbf, 0xf6, 0x29, 0x5f, 0x84, 0x26, 0x1a, 0x18, 0xc3, 0x6d, 0xef, 0x76, + 0x41, 0xaa, 0xf1, 0x3e, 0x0c, 0xf1, 0x27, 0xd4, 0x07, 0x09, 0x2c, 0xf1, 0xcb, 0x24, 0xbe, 0x02, + 0x16, 0xf3, 0xb0, 0x34, 0x54, 0x66, 0x7b, 0x60, 0x0c, 0x3b, 0xae, 0x5b, 0x24, 0xf8, 0xb1, 0xb0, + 0x6f, 0x06, 0x52, 0xa5, 0x52, 0xa9, 0x30, 0x26, 0x42, 0xd2, 0x94, 0xc1, 0x84, 0x1c, 0x66, 0x70, + 0xb1, 0xb0, 0x77, 0xe7, 0x2c, 0x4d, 0x1e, 0x39, 0xff, 0x36, 0x72, 0xbc, 0x5b, 0x1a, 0x3c, 0xd2, + 0xd8, 0x48, 0x43, 0x3a, 0x8f, 0xc2, 0x6f, 0x50, 0x77, 0x23, 0x7d, 0x22, 0x83, 0x58, 0x99, 0x1d, + 0xbd, 0xa6, 0x7b, 0xff, 0x5f, 0xd3, 0x91, 0x0c, 0xe2, 0x6a, 0x49, 0x18, 0x36, 0x01, 0xe5, 0x7c, + 0x31, 0xd0, 0xce, 0x25, 0x3e, 0x36, 0xd1, 0x55, 0x16, 0x86, 0x39, 0x57, 0xe5, 0xff, 0x6d, 0x79, + 0xeb, 0x11, 0xf7, 0x50, 0x53, 0x01, 0x83, 0x99, 0x32, 0xaf, 0x68, 0xa0, 0x9a, 0x70, 0x84, 0xae, + 0x07, 0x32, 0x9d, 0x26, 0x1c, 0x84, 0xcc, 0xfc, 0xa2, 0x61, 0xe6, 0x96, 0x6e, 0x46, 0x9f, 0x94, + 0xf5, 0x23, 0xeb, 0xfa, 0x91, 0xe3, 0x75, 0xfd, 0x5c, 0xa7, 0x88, 0x75, 0xb1, 0xb0, 0x7b, 0xe5, + 0x82, 0x36, 0x0c, 0x9c, 0xd3, 0x9f, 0xb6, 0xe1, 0x5d, 0xfb, 0x7b, 0x5b, 0x08, 0xdd, 0x83, 0xb3, + 0xa5, 0x65, 0x9c, 0x2f, 0x2d, 0xe3, 0xd7, 0xd2, 0x32, 0x4e, 0x57, 0x56, 0xe3, 0x7c, 0x65, 0x35, + 0xbe, 0xaf, 0xac, 0xc6, 0xeb, 0x07, 0x91, 0x80, 0xc9, 0x6c, 0x4c, 0x02, 0x99, 0xd2, 0x67, 0xaf, + 0x5e, 0x1e, 0x3c, 0xe7, 0xf0, 0x5e, 0xe6, 0x31, 0x0d, 0x26, 0x4c, 0x64, 0xf4, 0xc3, 0xba, 0xe0, + 0x30, 0x9f, 0x72, 0x35, 0x6e, 0xea, 0x38, 0x0f, 0xff, 0x04, 0x00, 0x00, 0xff, 0xff, 0xe0, 0x52, + 0xc3, 0x69, 0x7e, 0x03, 0x00, 0x00, } func (m *GenesisState) Marshal() (dAtA []byte, err error) { diff --git a/x/liquid/types/liquid.pb.go b/x/liquid/types/liquid.pb.go index 56825005..1582b800 100644 --- a/x/liquid/types/liquid.pb.go +++ b/x/liquid/types/liquid.pb.go @@ -1,5 +1,5 @@ // Code generated by protoc-gen-gogo. DO NOT EDIT. -// source: gaia/liquid/v1beta1/liquid.proto +// source: kyve/liquid/v1beta1/liquid.proto package types @@ -63,7 +63,7 @@ func (x TokenizeShareLockStatus) String() string { } func (TokenizeShareLockStatus) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_7b1e248decf35ce8, []int{0} + return fileDescriptor_83fe2aa3458e6a34, []int{0} } // Params defines the parameters for the x/liquid module. @@ -80,7 +80,7 @@ func (m *Params) Reset() { *m = Params{} } func (m *Params) String() string { return proto.CompactTextString(m) } func (*Params) ProtoMessage() {} func (*Params) Descriptor() ([]byte, []int) { - return fileDescriptor_7b1e248decf35ce8, []int{0} + return fileDescriptor_83fe2aa3458e6a34, []int{0} } func (m *Params) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -121,7 +121,7 @@ func (m *TokenizeShareRecord) Reset() { *m = TokenizeShareRecord{} } func (m *TokenizeShareRecord) String() string { return proto.CompactTextString(m) } func (*TokenizeShareRecord) ProtoMessage() {} func (*TokenizeShareRecord) Descriptor() ([]byte, []int) { - return fileDescriptor_7b1e248decf35ce8, []int{1} + return fileDescriptor_83fe2aa3458e6a34, []int{1} } func (m *TokenizeShareRecord) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -188,7 +188,7 @@ func (m *PendingTokenizeShareAuthorizations) Reset() { *m = PendingToken func (m *PendingTokenizeShareAuthorizations) String() string { return proto.CompactTextString(m) } func (*PendingTokenizeShareAuthorizations) ProtoMessage() {} func (*PendingTokenizeShareAuthorizations) Descriptor() ([]byte, []int) { - return fileDescriptor_7b1e248decf35ce8, []int{2} + return fileDescriptor_83fe2aa3458e6a34, []int{2} } func (m *PendingTokenizeShareAuthorizations) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -234,7 +234,7 @@ func (m *TokenizeShareRecordReward) Reset() { *m = TokenizeShareRecordRe func (m *TokenizeShareRecordReward) String() string { return proto.CompactTextString(m) } func (*TokenizeShareRecordReward) ProtoMessage() {} func (*TokenizeShareRecordReward) Descriptor() ([]byte, []int) { - return fileDescriptor_7b1e248decf35ce8, []int{3} + return fileDescriptor_83fe2aa3458e6a34, []int{3} } func (m *TokenizeShareRecordReward) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -277,7 +277,7 @@ func (m *LiquidValidator) Reset() { *m = LiquidValidator{} } func (m *LiquidValidator) String() string { return proto.CompactTextString(m) } func (*LiquidValidator) ProtoMessage() {} func (*LiquidValidator) Descriptor() ([]byte, []int) { - return fileDescriptor_7b1e248decf35ce8, []int{4} + return fileDescriptor_83fe2aa3458e6a34, []int{4} } func (m *LiquidValidator) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -307,65 +307,66 @@ func (m *LiquidValidator) XXX_DiscardUnknown() { var xxx_messageInfo_LiquidValidator proto.InternalMessageInfo func init() { - proto.RegisterEnum("gaia.liquid.v1beta1.TokenizeShareLockStatus", TokenizeShareLockStatus_name, TokenizeShareLockStatus_value) - proto.RegisterType((*Params)(nil), "gaia.liquid.v1beta1.Params") - proto.RegisterType((*TokenizeShareRecord)(nil), "gaia.liquid.v1beta1.TokenizeShareRecord") - proto.RegisterType((*PendingTokenizeShareAuthorizations)(nil), "gaia.liquid.v1beta1.PendingTokenizeShareAuthorizations") - proto.RegisterType((*TokenizeShareRecordReward)(nil), "gaia.liquid.v1beta1.TokenizeShareRecordReward") - proto.RegisterType((*LiquidValidator)(nil), "gaia.liquid.v1beta1.LiquidValidator") + proto.RegisterEnum("kyve.liquid.v1beta1.TokenizeShareLockStatus", TokenizeShareLockStatus_name, TokenizeShareLockStatus_value) + proto.RegisterType((*Params)(nil), "kyve.liquid.v1beta1.Params") + proto.RegisterType((*TokenizeShareRecord)(nil), "kyve.liquid.v1beta1.TokenizeShareRecord") + proto.RegisterType((*PendingTokenizeShareAuthorizations)(nil), "kyve.liquid.v1beta1.PendingTokenizeShareAuthorizations") + proto.RegisterType((*TokenizeShareRecordReward)(nil), "kyve.liquid.v1beta1.TokenizeShareRecordReward") + proto.RegisterType((*LiquidValidator)(nil), "kyve.liquid.v1beta1.LiquidValidator") } -func init() { proto.RegisterFile("gaia/liquid/v1beta1/liquid.proto", fileDescriptor_7b1e248decf35ce8) } +func init() { proto.RegisterFile("kyve/liquid/v1beta1/liquid.proto", fileDescriptor_83fe2aa3458e6a34) } -var fileDescriptor_7b1e248decf35ce8 = []byte{ - // 747 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x54, 0xcf, 0x4f, 0x13, 0x5b, - 0x14, 0xee, 0x6d, 0xfb, 0x08, 0xbd, 0xef, 0x01, 0x7d, 0x43, 0xf3, 0xde, 0x14, 0x78, 0xd3, 0xbe, - 0x21, 0x68, 0x53, 0xa5, 0x0d, 0xb2, 0xab, 0x0b, 0xd3, 0x5f, 0x6a, 0x43, 0x03, 0xcd, 0x4c, 0x31, - 0x86, 0xc4, 0x8c, 0xb7, 0x33, 0x37, 0xd3, 0x9b, 0xb6, 0x73, 0xeb, 0xdc, 0x29, 0x08, 0x7f, 0x80, - 0x21, 0xae, 0xdc, 0x98, 0xb8, 0x32, 0x24, 0x6e, 0x8c, 0x89, 0x09, 0x0b, 0xfe, 0x02, 0x57, 0xb8, - 0x23, 0xac, 0x8c, 0x0b, 0x24, 0xb0, 0xc0, 0xb5, 0x7f, 0x81, 0x99, 0xb9, 0xd3, 0x92, 0x2a, 0x22, - 0x9b, 0xf6, 0x9e, 0x73, 0xbe, 0xfb, 0xcd, 0x77, 0xce, 0x77, 0x66, 0x60, 0xd2, 0x44, 0x04, 0x65, - 0xdb, 0xe4, 0x49, 0x8f, 0x18, 0xd9, 0xf5, 0x85, 0x06, 0x76, 0xd0, 0x82, 0x1f, 0x66, 0xba, 0x36, - 0x75, 0xa8, 0x30, 0xe9, 0x22, 0x32, 0x7e, 0xca, 0x47, 0x4c, 0xc5, 0x4c, 0x6a, 0x52, 0xaf, 0x9e, - 0x75, 0x4f, 0x1c, 0x3a, 0xf5, 0x37, 0xea, 0x10, 0x8b, 0x66, 0xbd, 0x5f, 0x3f, 0x25, 0xe9, 0x94, - 0x75, 0x28, 0xcb, 0x36, 0x10, 0xc3, 0x03, 0x7e, 0x9d, 0x12, 0xcb, 0xaf, 0xc7, 0x79, 0x5d, 0xe3, - 0x5c, 0x3c, 0xe0, 0x25, 0xf9, 0x38, 0x08, 0x47, 0x6a, 0xc8, 0x46, 0x1d, 0x26, 0xbc, 0x04, 0x30, - 0x6e, 0xb6, 0x69, 0x03, 0xb5, 0x35, 0x2e, 0x44, 0x63, 0x0e, 0x6a, 0x11, 0xcb, 0xd4, 0x74, 0xd4, - 0x15, 0x47, 0x93, 0x20, 0x15, 0x29, 0xac, 0xed, 0x1f, 0x25, 0x02, 0x9f, 0x8f, 0x12, 0xd3, 0x9c, - 0x84, 0x19, 0xad, 0x0c, 0xa1, 0xd9, 0x0e, 0x72, 0x9a, 0x99, 0x2a, 0x36, 0x91, 0xbe, 0x59, 0xc2, - 0xfa, 0xb7, 0xa3, 0x44, 0x72, 0x13, 0x75, 0xda, 0x39, 0xf9, 0x97, 0x6c, 0xf2, 0xe1, 0xde, 0x3c, - 0xf4, 0x75, 0x94, 0xb0, 0xfe, 0xf6, 0x6c, 0x37, 0x0d, 0x94, 0x7f, 0x38, 0xbc, 0xea, 0xa1, 0x55, - 0x0e, 0x2e, 0xa2, 0xae, 0xf0, 0x1a, 0xc0, 0x99, 0x75, 0xd4, 0x26, 0x06, 0x72, 0xa8, 0x7d, 0x91, - 0xb4, 0x88, 0x27, 0xed, 0xd1, 0xd5, 0xa4, 0xcd, 0x72, 0x69, 0x97, 0x11, 0x5e, 0xa8, 0x2e, 0x3e, - 0xb8, 0xf1, 0xa3, 0xc0, 0xdc, 0x7f, 0x5f, 0x77, 0x12, 0xe0, 0xf9, 0xd9, 0x6e, 0x3a, 0xe6, 0xf9, - 0xfc, 0xb4, 0xef, 0x34, 0x9f, 0xab, 0xfc, 0x0c, 0xc0, 0xc9, 0x3a, 0x6d, 0x61, 0x8b, 0x6c, 0x61, - 0xb5, 0x89, 0x6c, 0xac, 0x60, 0x9d, 0xda, 0x86, 0x30, 0x0e, 0x83, 0xc4, 0x10, 0x41, 0x12, 0xa4, - 0xc2, 0x4a, 0x90, 0x18, 0x42, 0x0c, 0xfe, 0x41, 0x37, 0x2c, 0x6c, 0x8b, 0x41, 0xb7, 0x1f, 0x85, - 0x07, 0xc2, 0x1c, 0x1c, 0xef, 0x50, 0xa3, 0xd7, 0xc6, 0x1a, 0xd2, 0x75, 0xda, 0xb3, 0x1c, 0x31, - 0xe4, 0x95, 0xc7, 0x78, 0x36, 0xcf, 0x93, 0xc2, 0x0c, 0x8c, 0x0c, 0x04, 0x8a, 0x61, 0x0f, 0x71, - 0x9e, 0xc8, 0x85, 0x5d, 0x85, 0x72, 0x01, 0xca, 0x35, 0x6c, 0x19, 0xc4, 0x32, 0x87, 0xe4, 0xe4, - 0x7b, 0x4e, 0x93, 0xda, 0x64, 0x0b, 0x39, 0x84, 0x5a, 0xcc, 0x65, 0x42, 0x86, 0x61, 0x63, 0xc6, - 0x30, 0x13, 0x41, 0x32, 0xe4, 0x32, 0x0d, 0x12, 0xf2, 0x7b, 0x00, 0xe3, 0x17, 0x34, 0xa3, 0xe0, - 0x0d, 0x64, 0x1b, 0xc2, 0x34, 0x8c, 0xd8, 0x5e, 0xac, 0x0d, 0x3a, 0x1b, 0xe5, 0x89, 0x8a, 0x21, - 0x10, 0x38, 0x62, 0x7b, 0x30, 0x31, 0x98, 0x0c, 0xa5, 0xfe, 0xbc, 0x35, 0x93, 0xf1, 0x67, 0xec, - 0xae, 0x6d, 0x7f, 0xe9, 0xdd, 0x81, 0x17, 0x29, 0xb1, 0x0a, 0x8b, 0xae, 0x9d, 0xef, 0xbe, 0x24, - 0x6e, 0x98, 0xc4, 0x69, 0xf6, 0x1a, 0x19, 0x9d, 0x76, 0xfc, 0xcd, 0xf5, 0xff, 0xe6, 0x99, 0xd1, - 0xca, 0x3a, 0x9b, 0x5d, 0xcc, 0xfa, 0x77, 0x98, 0xe2, 0x3f, 0x20, 0x37, 0xba, 0xbd, 0x93, 0x08, - 0xbc, 0x72, 0x7b, 0xfe, 0x00, 0xe0, 0x04, 0x37, 0xec, 0x41, 0x7f, 0x1a, 0x42, 0x11, 0x46, 0x69, - 0x17, 0xdb, 0x9e, 0xfb, 0x7e, 0x67, 0x9e, 0xd8, 0x48, 0x41, 0x3c, 0xdc, 0x9b, 0x8f, 0xf9, 0xaa, - 0xf2, 0xbc, 0xa2, 0x3a, 0x36, 0xb1, 0x4c, 0x65, 0xa2, 0x7f, 0xc3, 0x4f, 0x0b, 0x8f, 0xe1, 0x58, - 0x7f, 0x73, 0xdc, 0x31, 0x30, 0x6e, 0x4b, 0xe1, 0xf6, 0xd5, 0xb6, 0x30, 0xc6, 0xb7, 0x70, 0x88, - 0x41, 0x56, 0xfe, 0xe2, 0xb1, 0x37, 0x57, 0x76, 0xde, 0x44, 0xfa, 0x23, 0x80, 0xff, 0x0e, 0x0d, - 0xbd, 0x4a, 0xf5, 0x96, 0xea, 0x20, 0xa7, 0xc7, 0x84, 0x34, 0xbc, 0x56, 0x5f, 0x59, 0x2a, 0x2f, - 0x57, 0xd6, 0xca, 0x9a, 0x7a, 0x3f, 0xaf, 0x94, 0xb5, 0xea, 0x4a, 0x71, 0x49, 0x53, 0xeb, 0xf9, - 0xfa, 0xaa, 0xaa, 0xad, 0x2e, 0xab, 0xb5, 0x72, 0xb1, 0x72, 0xb7, 0x52, 0x2e, 0x45, 0x03, 0xc2, - 0x1c, 0xfc, 0xff, 0x12, 0xac, 0x7b, 0x2e, 0x97, 0xa2, 0x40, 0xb8, 0x0e, 0x67, 0x2f, 0xa5, 0xf4, - 0x81, 0x41, 0xe1, 0x26, 0x4c, 0xfd, 0x86, 0x4f, 0x2b, 0x3f, 0xac, 0x55, 0x94, 0xca, 0xf2, 0xbd, - 0x68, 0x68, 0x2a, 0xbc, 0xfd, 0x46, 0x0a, 0x14, 0xee, 0xec, 0x9f, 0x48, 0xe0, 0xe0, 0x44, 0x02, - 0xc7, 0x27, 0x12, 0x78, 0x71, 0x2a, 0x05, 0x0e, 0x4e, 0xa5, 0xc0, 0xa7, 0x53, 0x29, 0xb0, 0x36, - 0xf7, 0xb3, 0xd3, 0xc3, 0xef, 0x93, 0x67, 0x76, 0x63, 0xc4, 0xfb, 0x70, 0x2d, 0x7e, 0x0f, 0x00, - 0x00, 0xff, 0xff, 0x0b, 0x71, 0x1b, 0x16, 0x55, 0x05, 0x00, 0x00, +var fileDescriptor_83fe2aa3458e6a34 = []byte{ + // 761 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x54, 0x4d, 0x4f, 0xe3, 0x46, + 0x18, 0xce, 0x24, 0x29, 0x22, 0xd3, 0x02, 0xa9, 0x89, 0x5a, 0x07, 0xa8, 0x93, 0x1a, 0xd1, 0x46, + 0x69, 0x89, 0x45, 0xb9, 0xa5, 0xa7, 0x7c, 0xb8, 0x6d, 0x44, 0x14, 0x22, 0x3b, 0xa0, 0x16, 0xa9, + 0x72, 0x27, 0xf6, 0xc8, 0x19, 0x25, 0xf1, 0xa4, 0x1e, 0x07, 0x1a, 0x7e, 0x40, 0x85, 0x7a, 0xea, + 0xa5, 0x52, 0x4f, 0x15, 0x52, 0x2f, 0xab, 0x95, 0x56, 0xe2, 0xc0, 0x2f, 0xd8, 0x13, 0x7b, 0x43, + 0x9c, 0x56, 0x7b, 0x60, 0x11, 0x1c, 0xd8, 0xf3, 0xfe, 0x82, 0x95, 0x3d, 0x4e, 0x58, 0x56, 0x2c, + 0xcb, 0x25, 0x99, 0xf7, 0x79, 0x9f, 0x79, 0xfc, 0xbc, 0x1f, 0x36, 0xcc, 0x76, 0x47, 0xbb, 0x58, + 0xe9, 0x91, 0xdf, 0x87, 0xc4, 0x52, 0x76, 0xd7, 0xda, 0xd8, 0x43, 0x6b, 0x61, 0x58, 0x18, 0xb8, + 0xd4, 0xa3, 0xc2, 0xbc, 0xcf, 0x28, 0x84, 0x50, 0xc8, 0x58, 0xf8, 0x14, 0xf5, 0x89, 0x43, 0x95, + 0xe0, 0x97, 0xf3, 0x16, 0x24, 0x93, 0xb2, 0x3e, 0x65, 0x4a, 0x1b, 0x31, 0x3c, 0x51, 0x32, 0x29, + 0x71, 0xc2, 0x7c, 0x9a, 0xe7, 0x8d, 0x20, 0x52, 0x78, 0x10, 0xa6, 0x52, 0x36, 0xb5, 0x29, 0xc7, + 0xfd, 0x13, 0x47, 0xe5, 0x8b, 0x28, 0x9c, 0x6a, 0x22, 0x17, 0xf5, 0x99, 0xf0, 0x0f, 0x80, 0x69, + 0xbb, 0x47, 0xdb, 0xa8, 0x67, 0x70, 0x23, 0x06, 0xf3, 0x50, 0x97, 0x38, 0xb6, 0x61, 0xa2, 0x81, + 0x38, 0x9d, 0x05, 0xb9, 0x44, 0x79, 0xe7, 0xe4, 0x3c, 0x13, 0x79, 0x71, 0x9e, 0x59, 0xe4, 0xd2, + 0xcc, 0xea, 0x16, 0x08, 0x55, 0xfa, 0xc8, 0xeb, 0x14, 0xea, 0xd8, 0x46, 0xe6, 0xa8, 0x8a, 0xcd, + 0xd7, 0xe7, 0x99, 0xec, 0x08, 0xf5, 0x7b, 0x45, 0xf9, 0xbd, 0x6a, 0xf2, 0xd9, 0xf1, 0x2a, 0x0c, + 0xdd, 0x55, 0xb1, 0xf9, 0xe8, 0xfa, 0x28, 0x0f, 0xb4, 0xcf, 0x38, 0xbd, 0x1e, 0xb0, 0x75, 0x4e, + 0xae, 0xa0, 0x81, 0xf0, 0x1f, 0x80, 0x4b, 0xbb, 0xa8, 0x47, 0x2c, 0xe4, 0x51, 0xf7, 0x2e, 0x6b, + 0x89, 0xc0, 0xda, 0xaf, 0x0f, 0xb3, 0xb6, 0xcc, 0xad, 0xdd, 0x27, 0x78, 0xa7, 0xbb, 0xf4, 0xe4, + 0xc6, 0xbb, 0x06, 0x8b, 0x5f, 0xbc, 0x3a, 0xcc, 0x80, 0xbf, 0xae, 0x8f, 0xf2, 0x29, 0x1b, 0x11, + 0xa4, 0xfc, 0x31, 0x9e, 0x34, 0xef, 0xab, 0xfc, 0x27, 0x80, 0xf3, 0x2d, 0xda, 0xc5, 0x0e, 0xd9, + 0xc7, 0x7a, 0x07, 0xb9, 0x58, 0xc3, 0x26, 0x75, 0x2d, 0x61, 0x16, 0x46, 0x89, 0x25, 0x82, 0x2c, + 0xc8, 0xc5, 0xb5, 0x28, 0xb1, 0x84, 0x14, 0xfc, 0x88, 0xee, 0x39, 0xd8, 0x15, 0xa3, 0x7e, 0x3d, + 0x1a, 0x0f, 0x84, 0x15, 0x38, 0xdb, 0xa7, 0xd6, 0xb0, 0x87, 0x0d, 0x64, 0x9a, 0x74, 0xe8, 0x78, + 0x62, 0x2c, 0x48, 0xcf, 0x70, 0xb4, 0xc4, 0x41, 0x61, 0x09, 0x26, 0x26, 0x06, 0xc5, 0x78, 0xc0, + 0xb8, 0x01, 0x8a, 0x71, 0xdf, 0xa1, 0x5c, 0x86, 0x72, 0x13, 0x3b, 0x16, 0x71, 0xec, 0x5b, 0x76, + 0x4a, 0x43, 0xaf, 0x43, 0x5d, 0xb2, 0x8f, 0x3c, 0x42, 0x1d, 0xe6, 0x2b, 0x21, 0xcb, 0x72, 0x31, + 0x63, 0x98, 0x89, 0x20, 0x1b, 0xf3, 0x95, 0x26, 0x80, 0xfc, 0x04, 0xc0, 0xf4, 0x1d, 0xc5, 0x68, + 0x78, 0x0f, 0xb9, 0x96, 0xb0, 0x08, 0x13, 0x6e, 0x10, 0x1b, 0x93, 0xca, 0xa6, 0x39, 0x50, 0xb3, + 0x04, 0x02, 0xa7, 0xdc, 0x80, 0x26, 0x46, 0xb3, 0xb1, 0xdc, 0xc7, 0xdf, 0x2d, 0x15, 0xc2, 0x1e, + 0xfb, 0xcb, 0x3c, 0x5e, 0x7a, 0xbf, 0xe1, 0x15, 0x4a, 0x9c, 0xf2, 0xba, 0x3f, 0xce, 0xc7, 0x2f, + 0x33, 0xdf, 0xd8, 0xc4, 0xeb, 0x0c, 0xdb, 0x05, 0x93, 0xf6, 0xc3, 0x7d, 0x0e, 0xff, 0x56, 0x99, + 0xd5, 0x55, 0xbc, 0xd1, 0x00, 0xb3, 0xf1, 0x1d, 0xa6, 0x85, 0x0f, 0x28, 0x4e, 0x1f, 0x1c, 0x66, + 0x22, 0xff, 0xfa, 0x35, 0x3f, 0x05, 0x70, 0x8e, 0x0f, 0x6c, 0x7b, 0xdc, 0x0d, 0xa1, 0x02, 0x93, + 0x74, 0x80, 0xdd, 0x60, 0xfa, 0x61, 0x65, 0x81, 0xd9, 0x44, 0x59, 0x3c, 0x3b, 0x5e, 0x4d, 0x85, + 0xae, 0x4a, 0x3c, 0xa3, 0x7b, 0x2e, 0x71, 0x6c, 0x6d, 0x6e, 0x7c, 0x23, 0x84, 0x85, 0xdf, 0xe0, + 0xcc, 0x78, 0x73, 0xfc, 0x36, 0x30, 0x3e, 0x96, 0xf2, 0xf7, 0x0f, 0xdb, 0xc2, 0x14, 0xdf, 0xc2, + 0x5b, 0x0a, 0xb2, 0xf6, 0x09, 0x8f, 0x83, 0xbe, 0xb2, 0x9b, 0x22, 0xf2, 0xcf, 0x00, 0xfc, 0xfc, + 0x56, 0xd3, 0xeb, 0xd4, 0xec, 0xea, 0x1e, 0xf2, 0x86, 0x4c, 0xc8, 0xc3, 0xaf, 0x5a, 0x9b, 0x1b, + 0x6a, 0xa3, 0xb6, 0xa3, 0x1a, 0xfa, 0x4f, 0x25, 0x4d, 0x35, 0xea, 0x9b, 0x95, 0x0d, 0x43, 0x6f, + 0x95, 0x5a, 0x5b, 0xba, 0xb1, 0xd5, 0xd0, 0x9b, 0x6a, 0xa5, 0xf6, 0x43, 0x4d, 0xad, 0x26, 0x23, + 0xc2, 0x0a, 0xfc, 0xf2, 0x1e, 0xae, 0x7f, 0x56, 0xab, 0x49, 0x20, 0x7c, 0x0d, 0x97, 0xef, 0x95, + 0x0c, 0x89, 0x51, 0xe1, 0x5b, 0x98, 0xfb, 0x80, 0x9e, 0xa1, 0xfe, 0xdc, 0xac, 0x69, 0xb5, 0xc6, + 0x8f, 0xc9, 0xd8, 0x42, 0xfc, 0xe0, 0x7f, 0x29, 0x52, 0x56, 0x4f, 0x2e, 0x25, 0x70, 0x7a, 0x29, + 0x81, 0x8b, 0x4b, 0x09, 0xfc, 0x7d, 0x25, 0x45, 0x4e, 0xaf, 0xa4, 0xc8, 0xf3, 0x2b, 0x29, 0xb2, + 0xf3, 0xf6, 0xa4, 0x37, 0x7e, 0xd9, 0x56, 0x1b, 0xd8, 0xdb, 0xa3, 0x6e, 0x57, 0x31, 0x3b, 0x88, + 0x38, 0x37, 0x6f, 0x55, 0x30, 0xf2, 0xf6, 0x54, 0xf0, 0xf9, 0x5a, 0x7f, 0x13, 0x00, 0x00, 0xff, + 0xff, 0x97, 0x6f, 0x0f, 0x8e, 0x5b, 0x05, 0x00, 0x00, } func (this *Params) Equal(that interface{}) bool { diff --git a/x/liquid/types/query.pb.go b/x/liquid/types/query.pb.go index c7d6bf8c..eafc8105 100644 --- a/x/liquid/types/query.pb.go +++ b/x/liquid/types/query.pb.go @@ -1,5 +1,5 @@ // Code generated by protoc-gen-gogo. DO NOT EDIT. -// source: gaia/liquid/v1beta1/query.proto +// source: kyve/liquid/v1beta1/query.proto package types @@ -43,7 +43,7 @@ func (m *QueryLiquidValidatorRequest) Reset() { *m = QueryLiquidValidato func (m *QueryLiquidValidatorRequest) String() string { return proto.CompactTextString(m) } func (*QueryLiquidValidatorRequest) ProtoMessage() {} func (*QueryLiquidValidatorRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_a7f79c476d0ac005, []int{0} + return fileDescriptor_1a9d927347bb19fc, []int{0} } func (m *QueryLiquidValidatorRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -89,7 +89,7 @@ func (m *QueryLiquidValidatorResponse) Reset() { *m = QueryLiquidValidat func (m *QueryLiquidValidatorResponse) String() string { return proto.CompactTextString(m) } func (*QueryLiquidValidatorResponse) ProtoMessage() {} func (*QueryLiquidValidatorResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_a7f79c476d0ac005, []int{1} + return fileDescriptor_1a9d927347bb19fc, []int{1} } func (m *QueryLiquidValidatorResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -136,7 +136,7 @@ func (m *QueryLiquidValidatorsRequest) Reset() { *m = QueryLiquidValidat func (m *QueryLiquidValidatorsRequest) String() string { return proto.CompactTextString(m) } func (*QueryLiquidValidatorsRequest) ProtoMessage() {} func (*QueryLiquidValidatorsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_a7f79c476d0ac005, []int{2} + return fileDescriptor_1a9d927347bb19fc, []int{2} } func (m *QueryLiquidValidatorsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -184,7 +184,7 @@ func (m *QueryLiquidValidatorsResponse) Reset() { *m = QueryLiquidValida func (m *QueryLiquidValidatorsResponse) String() string { return proto.CompactTextString(m) } func (*QueryLiquidValidatorsResponse) ProtoMessage() {} func (*QueryLiquidValidatorsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_a7f79c476d0ac005, []int{3} + return fileDescriptor_1a9d927347bb19fc, []int{3} } func (m *QueryLiquidValidatorsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -235,7 +235,7 @@ func (m *QueryParamsRequest) Reset() { *m = QueryParamsRequest{} } func (m *QueryParamsRequest) String() string { return proto.CompactTextString(m) } func (*QueryParamsRequest) ProtoMessage() {} func (*QueryParamsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_a7f79c476d0ac005, []int{4} + return fileDescriptor_1a9d927347bb19fc, []int{4} } func (m *QueryParamsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -274,7 +274,7 @@ func (m *QueryParamsResponse) Reset() { *m = QueryParamsResponse{} } func (m *QueryParamsResponse) String() string { return proto.CompactTextString(m) } func (*QueryParamsResponse) ProtoMessage() {} func (*QueryParamsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_a7f79c476d0ac005, []int{5} + return fileDescriptor_1a9d927347bb19fc, []int{5} } func (m *QueryParamsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -320,7 +320,7 @@ func (m *QueryTokenizeShareRecordByIdRequest) Reset() { *m = QueryTokeni func (m *QueryTokenizeShareRecordByIdRequest) String() string { return proto.CompactTextString(m) } func (*QueryTokenizeShareRecordByIdRequest) ProtoMessage() {} func (*QueryTokenizeShareRecordByIdRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_a7f79c476d0ac005, []int{6} + return fileDescriptor_1a9d927347bb19fc, []int{6} } func (m *QueryTokenizeShareRecordByIdRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -366,7 +366,7 @@ func (m *QueryTokenizeShareRecordByIdResponse) Reset() { *m = QueryToken func (m *QueryTokenizeShareRecordByIdResponse) String() string { return proto.CompactTextString(m) } func (*QueryTokenizeShareRecordByIdResponse) ProtoMessage() {} func (*QueryTokenizeShareRecordByIdResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_a7f79c476d0ac005, []int{7} + return fileDescriptor_1a9d927347bb19fc, []int{7} } func (m *QueryTokenizeShareRecordByIdResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -414,7 +414,7 @@ func (m *QueryTokenizeShareRecordByDenomRequest) Reset() { func (m *QueryTokenizeShareRecordByDenomRequest) String() string { return proto.CompactTextString(m) } func (*QueryTokenizeShareRecordByDenomRequest) ProtoMessage() {} func (*QueryTokenizeShareRecordByDenomRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_a7f79c476d0ac005, []int{8} + return fileDescriptor_1a9d927347bb19fc, []int{8} } func (m *QueryTokenizeShareRecordByDenomRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -462,7 +462,7 @@ func (m *QueryTokenizeShareRecordByDenomResponse) Reset() { func (m *QueryTokenizeShareRecordByDenomResponse) String() string { return proto.CompactTextString(m) } func (*QueryTokenizeShareRecordByDenomResponse) ProtoMessage() {} func (*QueryTokenizeShareRecordByDenomResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_a7f79c476d0ac005, []int{9} + return fileDescriptor_1a9d927347bb19fc, []int{9} } func (m *QueryTokenizeShareRecordByDenomResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -508,7 +508,7 @@ func (m *QueryTokenizeShareRecordsOwnedRequest) Reset() { *m = QueryToke func (m *QueryTokenizeShareRecordsOwnedRequest) String() string { return proto.CompactTextString(m) } func (*QueryTokenizeShareRecordsOwnedRequest) ProtoMessage() {} func (*QueryTokenizeShareRecordsOwnedRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_a7f79c476d0ac005, []int{10} + return fileDescriptor_1a9d927347bb19fc, []int{10} } func (m *QueryTokenizeShareRecordsOwnedRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -556,7 +556,7 @@ func (m *QueryTokenizeShareRecordsOwnedResponse) Reset() { func (m *QueryTokenizeShareRecordsOwnedResponse) String() string { return proto.CompactTextString(m) } func (*QueryTokenizeShareRecordsOwnedResponse) ProtoMessage() {} func (*QueryTokenizeShareRecordsOwnedResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_a7f79c476d0ac005, []int{11} + return fileDescriptor_1a9d927347bb19fc, []int{11} } func (m *QueryTokenizeShareRecordsOwnedResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -603,7 +603,7 @@ func (m *QueryAllTokenizeShareRecordsRequest) Reset() { *m = QueryAllTok func (m *QueryAllTokenizeShareRecordsRequest) String() string { return proto.CompactTextString(m) } func (*QueryAllTokenizeShareRecordsRequest) ProtoMessage() {} func (*QueryAllTokenizeShareRecordsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_a7f79c476d0ac005, []int{12} + return fileDescriptor_1a9d927347bb19fc, []int{12} } func (m *QueryAllTokenizeShareRecordsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -651,7 +651,7 @@ func (m *QueryAllTokenizeShareRecordsResponse) Reset() { *m = QueryAllTo func (m *QueryAllTokenizeShareRecordsResponse) String() string { return proto.CompactTextString(m) } func (*QueryAllTokenizeShareRecordsResponse) ProtoMessage() {} func (*QueryAllTokenizeShareRecordsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_a7f79c476d0ac005, []int{13} + return fileDescriptor_1a9d927347bb19fc, []int{13} } func (m *QueryAllTokenizeShareRecordsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -703,7 +703,7 @@ func (m *QueryLastTokenizeShareRecordIdRequest) Reset() { *m = QueryLast func (m *QueryLastTokenizeShareRecordIdRequest) String() string { return proto.CompactTextString(m) } func (*QueryLastTokenizeShareRecordIdRequest) ProtoMessage() {} func (*QueryLastTokenizeShareRecordIdRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_a7f79c476d0ac005, []int{14} + return fileDescriptor_1a9d927347bb19fc, []int{14} } func (m *QueryLastTokenizeShareRecordIdRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -744,7 +744,7 @@ func (m *QueryLastTokenizeShareRecordIdResponse) Reset() { func (m *QueryLastTokenizeShareRecordIdResponse) String() string { return proto.CompactTextString(m) } func (*QueryLastTokenizeShareRecordIdResponse) ProtoMessage() {} func (*QueryLastTokenizeShareRecordIdResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_a7f79c476d0ac005, []int{15} + return fileDescriptor_1a9d927347bb19fc, []int{15} } func (m *QueryLastTokenizeShareRecordIdResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -789,7 +789,7 @@ func (m *QueryTotalTokenizeSharedAssetsRequest) Reset() { *m = QueryTota func (m *QueryTotalTokenizeSharedAssetsRequest) String() string { return proto.CompactTextString(m) } func (*QueryTotalTokenizeSharedAssetsRequest) ProtoMessage() {} func (*QueryTotalTokenizeSharedAssetsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_a7f79c476d0ac005, []int{16} + return fileDescriptor_1a9d927347bb19fc, []int{16} } func (m *QueryTotalTokenizeSharedAssetsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -830,7 +830,7 @@ func (m *QueryTotalTokenizeSharedAssetsResponse) Reset() { func (m *QueryTotalTokenizeSharedAssetsResponse) String() string { return proto.CompactTextString(m) } func (*QueryTotalTokenizeSharedAssetsResponse) ProtoMessage() {} func (*QueryTotalTokenizeSharedAssetsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_a7f79c476d0ac005, []int{17} + return fileDescriptor_1a9d927347bb19fc, []int{17} } func (m *QueryTotalTokenizeSharedAssetsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -875,7 +875,7 @@ func (m *QueryTotalLiquidStaked) Reset() { *m = QueryTotalLiquidStaked{} func (m *QueryTotalLiquidStaked) String() string { return proto.CompactTextString(m) } func (*QueryTotalLiquidStaked) ProtoMessage() {} func (*QueryTotalLiquidStaked) Descriptor() ([]byte, []int) { - return fileDescriptor_a7f79c476d0ac005, []int{18} + return fileDescriptor_1a9d927347bb19fc, []int{18} } func (m *QueryTotalLiquidStaked) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -914,7 +914,7 @@ func (m *QueryTotalLiquidStakedResponse) Reset() { *m = QueryTotalLiquid func (m *QueryTotalLiquidStakedResponse) String() string { return proto.CompactTextString(m) } func (*QueryTotalLiquidStakedResponse) ProtoMessage() {} func (*QueryTotalLiquidStakedResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_a7f79c476d0ac005, []int{19} + return fileDescriptor_1a9d927347bb19fc, []int{19} } func (m *QueryTotalLiquidStakedResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -960,7 +960,7 @@ func (m *QueryTokenizeShareLockInfo) Reset() { *m = QueryTokenizeShareLo func (m *QueryTokenizeShareLockInfo) String() string { return proto.CompactTextString(m) } func (*QueryTokenizeShareLockInfo) ProtoMessage() {} func (*QueryTokenizeShareLockInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_a7f79c476d0ac005, []int{20} + return fileDescriptor_1a9d927347bb19fc, []int{20} } func (m *QueryTokenizeShareLockInfo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1007,7 +1007,7 @@ func (m *QueryTokenizeShareLockInfoResponse) Reset() { *m = QueryTokeniz func (m *QueryTokenizeShareLockInfoResponse) String() string { return proto.CompactTextString(m) } func (*QueryTokenizeShareLockInfoResponse) ProtoMessage() {} func (*QueryTokenizeShareLockInfoResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_a7f79c476d0ac005, []int{21} + return fileDescriptor_1a9d927347bb19fc, []int{21} } func (m *QueryTokenizeShareLockInfoResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1060,7 +1060,7 @@ func (m *QueryTokenizeShareRecordRewardRequest) Reset() { *m = QueryToke func (m *QueryTokenizeShareRecordRewardRequest) String() string { return proto.CompactTextString(m) } func (*QueryTokenizeShareRecordRewardRequest) ProtoMessage() {} func (*QueryTokenizeShareRecordRewardRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_a7f79c476d0ac005, []int{22} + return fileDescriptor_1a9d927347bb19fc, []int{22} } func (m *QueryTokenizeShareRecordRewardRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1104,7 +1104,7 @@ func (m *QueryTokenizeShareRecordRewardResponse) Reset() { func (m *QueryTokenizeShareRecordRewardResponse) String() string { return proto.CompactTextString(m) } func (*QueryTokenizeShareRecordRewardResponse) ProtoMessage() {} func (*QueryTokenizeShareRecordRewardResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_a7f79c476d0ac005, []int{23} + return fileDescriptor_1a9d927347bb19fc, []int{23} } func (m *QueryTokenizeShareRecordRewardResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1148,119 +1148,120 @@ func (m *QueryTokenizeShareRecordRewardResponse) GetTotal() github_com_cosmos_co } func init() { - proto.RegisterType((*QueryLiquidValidatorRequest)(nil), "gaia.liquid.v1beta1.QueryLiquidValidatorRequest") - proto.RegisterType((*QueryLiquidValidatorResponse)(nil), "gaia.liquid.v1beta1.QueryLiquidValidatorResponse") - proto.RegisterType((*QueryLiquidValidatorsRequest)(nil), "gaia.liquid.v1beta1.QueryLiquidValidatorsRequest") - proto.RegisterType((*QueryLiquidValidatorsResponse)(nil), "gaia.liquid.v1beta1.QueryLiquidValidatorsResponse") - proto.RegisterType((*QueryParamsRequest)(nil), "gaia.liquid.v1beta1.QueryParamsRequest") - proto.RegisterType((*QueryParamsResponse)(nil), "gaia.liquid.v1beta1.QueryParamsResponse") - proto.RegisterType((*QueryTokenizeShareRecordByIdRequest)(nil), "gaia.liquid.v1beta1.QueryTokenizeShareRecordByIdRequest") - proto.RegisterType((*QueryTokenizeShareRecordByIdResponse)(nil), "gaia.liquid.v1beta1.QueryTokenizeShareRecordByIdResponse") - proto.RegisterType((*QueryTokenizeShareRecordByDenomRequest)(nil), "gaia.liquid.v1beta1.QueryTokenizeShareRecordByDenomRequest") - proto.RegisterType((*QueryTokenizeShareRecordByDenomResponse)(nil), "gaia.liquid.v1beta1.QueryTokenizeShareRecordByDenomResponse") - proto.RegisterType((*QueryTokenizeShareRecordsOwnedRequest)(nil), "gaia.liquid.v1beta1.QueryTokenizeShareRecordsOwnedRequest") - proto.RegisterType((*QueryTokenizeShareRecordsOwnedResponse)(nil), "gaia.liquid.v1beta1.QueryTokenizeShareRecordsOwnedResponse") - proto.RegisterType((*QueryAllTokenizeShareRecordsRequest)(nil), "gaia.liquid.v1beta1.QueryAllTokenizeShareRecordsRequest") - proto.RegisterType((*QueryAllTokenizeShareRecordsResponse)(nil), "gaia.liquid.v1beta1.QueryAllTokenizeShareRecordsResponse") - proto.RegisterType((*QueryLastTokenizeShareRecordIdRequest)(nil), "gaia.liquid.v1beta1.QueryLastTokenizeShareRecordIdRequest") - proto.RegisterType((*QueryLastTokenizeShareRecordIdResponse)(nil), "gaia.liquid.v1beta1.QueryLastTokenizeShareRecordIdResponse") - proto.RegisterType((*QueryTotalTokenizeSharedAssetsRequest)(nil), "gaia.liquid.v1beta1.QueryTotalTokenizeSharedAssetsRequest") - proto.RegisterType((*QueryTotalTokenizeSharedAssetsResponse)(nil), "gaia.liquid.v1beta1.QueryTotalTokenizeSharedAssetsResponse") - proto.RegisterType((*QueryTotalLiquidStaked)(nil), "gaia.liquid.v1beta1.QueryTotalLiquidStaked") - proto.RegisterType((*QueryTotalLiquidStakedResponse)(nil), "gaia.liquid.v1beta1.QueryTotalLiquidStakedResponse") - proto.RegisterType((*QueryTokenizeShareLockInfo)(nil), "gaia.liquid.v1beta1.QueryTokenizeShareLockInfo") - proto.RegisterType((*QueryTokenizeShareLockInfoResponse)(nil), "gaia.liquid.v1beta1.QueryTokenizeShareLockInfoResponse") - proto.RegisterType((*QueryTokenizeShareRecordRewardRequest)(nil), "gaia.liquid.v1beta1.QueryTokenizeShareRecordRewardRequest") - proto.RegisterType((*QueryTokenizeShareRecordRewardResponse)(nil), "gaia.liquid.v1beta1.QueryTokenizeShareRecordRewardResponse") -} - -func init() { proto.RegisterFile("gaia/liquid/v1beta1/query.proto", fileDescriptor_a7f79c476d0ac005) } - -var fileDescriptor_a7f79c476d0ac005 = []byte{ - // 1323 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x58, 0xcf, 0x6f, 0x1b, 0x45, - 0x14, 0xf6, 0x86, 0x26, 0xa5, 0x03, 0xfd, 0x91, 0x69, 0x68, 0x9d, 0x4d, 0x6a, 0x47, 0x43, 0x13, - 0x5b, 0x89, 0xea, 0x6d, 0x62, 0xd2, 0xfc, 0x22, 0x29, 0x49, 0xa3, 0x42, 0x51, 0x04, 0xc5, 0x2d, - 0x1c, 0x2a, 0xa4, 0xd5, 0xc4, 0x3b, 0x71, 0x57, 0xb1, 0x77, 0x9c, 0x9d, 0x75, 0xd2, 0xd4, 0xf2, - 0x05, 0x09, 0xa9, 0x47, 0x24, 0xfe, 0x81, 0xde, 0x40, 0x1c, 0x10, 0x27, 0x24, 0x2e, 0x1c, 0x40, - 0x42, 0xbd, 0x20, 0x22, 0x21, 0x21, 0x0e, 0xa8, 0x94, 0x04, 0x09, 0xce, 0xfc, 0x05, 0x68, 0x67, - 0x66, 0x37, 0x5e, 0x67, 0x77, 0x6d, 0x47, 0xb9, 0xc4, 0xde, 0xd9, 0xf7, 0xcd, 0xfb, 0xbe, 0x99, - 0xf7, 0x66, 0x3e, 0x07, 0xa4, 0x4b, 0xd8, 0xc4, 0x5a, 0xd9, 0xdc, 0xaa, 0x99, 0x86, 0xb6, 0x3d, - 0xb9, 0x4e, 0x1c, 0x3c, 0xa9, 0x6d, 0xd5, 0x88, 0xbd, 0x9b, 0xab, 0xda, 0xd4, 0xa1, 0xf0, 0xa2, - 0x1b, 0x90, 0x13, 0x01, 0x39, 0x19, 0xa0, 0x8e, 0x17, 0x29, 0xab, 0x50, 0xa6, 0xad, 0x63, 0x46, - 0x44, 0xb4, 0x8f, 0xad, 0xe2, 0x92, 0x69, 0x61, 0xc7, 0xa4, 0x96, 0x98, 0x40, 0x1d, 0x28, 0xd1, - 0x12, 0xe5, 0x5f, 0x35, 0xf7, 0x9b, 0x1c, 0x1d, 0x2e, 0x51, 0x5a, 0x2a, 0x13, 0x0d, 0x57, 0x4d, - 0x0d, 0x5b, 0x16, 0x75, 0x38, 0x84, 0xc9, 0xb7, 0x23, 0x61, 0xac, 0x24, 0x07, 0x11, 0x91, 0x6a, - 0x66, 0xe0, 0x45, 0x14, 0xa9, 0xe9, 0x65, 0x1d, 0x92, 0xef, 0x3d, 0x72, 0xcd, 0x9a, 0xd4, 0x7e, - 0x5c, 0x31, 0x2d, 0xaa, 0xf1, 0xbf, 0x62, 0x08, 0xad, 0x82, 0xa1, 0x0f, 0xdc, 0x88, 0x35, 0x9e, - 0xe4, 0x23, 0x5c, 0x36, 0x0d, 0xec, 0x50, 0xbb, 0x40, 0xb6, 0x6a, 0x84, 0x39, 0x70, 0x14, 0x9c, - 0xdb, 0xf6, 0xc6, 0x74, 0x6c, 0x18, 0x76, 0x52, 0x19, 0x51, 0xb2, 0x67, 0x0a, 0x67, 0xfd, 0xd1, - 0x65, 0xc3, 0xb0, 0xd1, 0x63, 0x30, 0x1c, 0x3e, 0x0b, 0xab, 0x52, 0x8b, 0x11, 0xf8, 0x00, 0x5c, - 0x10, 0x2a, 0x74, 0x1f, 0xc7, 0x27, 0x7a, 0x65, 0xea, 0x6a, 0x2e, 0x64, 0x9d, 0x73, 0x2d, 0xf3, - 0xac, 0x9c, 0x79, 0xf6, 0x3c, 0x9d, 0xf8, 0xf2, 0x9f, 0x6f, 0xc6, 0x95, 0xc2, 0xf9, 0x72, 0xf0, - 0x1d, 0xda, 0x08, 0xcf, 0xcd, 0x3c, 0x09, 0xb7, 0x01, 0x38, 0xdc, 0x1b, 0x99, 0x75, 0x2c, 0x27, - 0x96, 0x29, 0xe7, 0x2e, 0x63, 0x4e, 0x2c, 0x91, 0x97, 0xfb, 0x2e, 0x2e, 0x11, 0x89, 0x2d, 0x34, - 0x21, 0xd1, 0x4f, 0x0a, 0xb8, 0x12, 0x91, 0x48, 0xaa, 0xfc, 0x18, 0xf4, 0xb7, 0xaa, 0x64, 0x49, - 0x65, 0xe4, 0xa5, 0xe3, 0xc8, 0xbc, 0xd0, 0x22, 0x93, 0xc1, 0xb7, 0x03, 0x3a, 0x7a, 0xb8, 0x8e, - 0x4c, 0x5b, 0x1d, 0x82, 0x5a, 0x40, 0xc8, 0x00, 0x80, 0x5c, 0xc7, 0x5d, 0x6c, 0xe3, 0x8a, 0xb7, - 0x4c, 0xe8, 0x43, 0x70, 0x31, 0x30, 0x2a, 0x35, 0x2d, 0x81, 0xbe, 0x2a, 0x1f, 0x91, 0x2b, 0x37, - 0x14, 0x2a, 0x44, 0x80, 0x9a, 0xf9, 0x4b, 0x14, 0x9a, 0x06, 0xaf, 0xf3, 0x69, 0xef, 0xd3, 0x4d, - 0x62, 0x99, 0x8f, 0xc9, 0xbd, 0x87, 0xd8, 0x26, 0x05, 0x52, 0xa4, 0xb6, 0xb1, 0xb2, 0x7b, 0xc7, - 0xf0, 0x36, 0xe9, 0x1c, 0xe8, 0x31, 0x0d, 0x9e, 0xe2, 0x54, 0xa1, 0xc7, 0x34, 0x90, 0x05, 0xae, - 0xc6, 0xc3, 0x24, 0xbd, 0xdb, 0xa0, 0xcf, 0xe6, 0xa3, 0x92, 0x5e, 0x36, 0x94, 0x5e, 0xd8, 0x2c, - 0xa7, 0x5c, 0xae, 0x05, 0x89, 0x46, 0x4b, 0x60, 0x2c, 0x3a, 0xdf, 0x2a, 0xb1, 0x68, 0xc5, 0x63, - 0x3a, 0x00, 0x7a, 0x0d, 0xf7, 0x59, 0x36, 0x82, 0x78, 0x40, 0x5b, 0x20, 0xd3, 0x16, 0x7f, 0xc2, - 0x94, 0x17, 0xc1, 0x68, 0x54, 0x4a, 0xf6, 0xfe, 0x8e, 0x45, 0x8c, 0x26, 0xc6, 0x74, 0xc7, 0x22, - 0x5e, 0xeb, 0x8a, 0x07, 0x64, 0x47, 0x2b, 0xf6, 0xe0, 0x92, 0xf0, 0x3b, 0xe0, 0xb4, 0x48, 0xe9, - 0x15, 0x73, 0xb7, 0x8c, 0x3d, 0x38, 0xaa, 0xc8, 0x62, 0x58, 0x2e, 0x97, 0xc3, 0xd2, 0x9e, 0x74, - 0xc7, 0x7e, 0xa7, 0xc8, 0x2a, 0x8a, 0xcc, 0x77, 0xd2, 0x0a, 0x4f, 0xae, 0x49, 0x33, 0x72, 0x77, - 0xd7, 0x30, 0x73, 0x42, 0xf2, 0xfa, 0x9d, 0x83, 0x66, 0xe5, 0x3e, 0xc6, 0x04, 0x4a, 0x95, 0xad, - 0x3d, 0x96, 0xf1, 0x0b, 0xc8, 0xc1, 0xc1, 0xf5, 0x31, 0x96, 0x19, 0x23, 0x8e, 0x7f, 0x34, 0xe8, - 0x7e, 0xa9, 0x44, 0x06, 0xca, 0x14, 0xd3, 0xa0, 0x77, 0x1b, 0x97, 0x6b, 0x44, 0x6e, 0xda, 0x60, - 0x40, 0xb9, 0xa7, 0xf9, 0x16, 0x35, 0x2d, 0xb9, 0x6e, 0x22, 0x1a, 0x25, 0xc1, 0xa5, 0xc3, 0x04, - 0xe2, 0x50, 0xbc, 0xe7, 0xe0, 0x4d, 0x62, 0xa0, 0x59, 0x90, 0x0a, 0x7f, 0xe3, 0xa7, 0xbc, 0x04, - 0xfa, 0x1c, 0x97, 0x12, 0x93, 0xe5, 0x2d, 0x9f, 0xd0, 0x0d, 0xa0, 0x1e, 0xad, 0xef, 0x35, 0x5a, - 0xdc, 0xbc, 0x63, 0x6d, 0x50, 0x98, 0x04, 0xa7, 0xdd, 0xdb, 0x8c, 0x30, 0x0f, 0xe6, 0x3d, 0x22, - 0x02, 0x50, 0x34, 0xae, 0x39, 0x2b, 0x73, 0xb0, 0x53, 0xf3, 0xb3, 0x8a, 0x27, 0x98, 0x01, 0xe7, - 0xc9, 0xa3, 0xaa, 0x69, 0xf3, 0x4d, 0xd4, 0x1d, 0xb3, 0x42, 0x78, 0x11, 0x9c, 0x29, 0x9c, 0x3b, - 0x1c, 0xbe, 0x6f, 0x56, 0x08, 0xaa, 0x46, 0x77, 0x6f, 0x81, 0xec, 0x60, 0xdb, 0xef, 0xde, 0x45, - 0x70, 0x96, 0x37, 0xac, 0x1e, 0xe0, 0xbb, 0x92, 0xfc, 0xef, 0x79, 0x7a, 0x60, 0x17, 0x57, 0xca, - 0xf3, 0x28, 0xf0, 0x1a, 0x15, 0x5e, 0xe5, 0xcf, 0xcb, 0xe2, 0x71, 0xfe, 0xe5, 0x27, 0x4f, 0xd3, - 0x89, 0x7f, 0x9f, 0xa6, 0x13, 0xe8, 0x2f, 0x25, 0xba, 0xe3, 0xbd, 0x94, 0x52, 0xdd, 0x7b, 0x6e, - 0x3f, 0xb8, 0x23, 0x5e, 0x3f, 0xe4, 0x3a, 0xed, 0x07, 0x31, 0xd1, 0x61, 0x57, 0xf0, 0x49, 0x60, - 0x09, 0xf4, 0x3a, 0xee, 0x06, 0x26, 0x7b, 0xf8, 0x6c, 0xc3, 0xa1, 0x65, 0xb1, 0x4a, 0x8a, 0xbc, - 0x32, 0xf2, 0x2e, 0xf6, 0xab, 0x3f, 0xd3, 0x13, 0x25, 0xd3, 0x79, 0x58, 0x5b, 0xcf, 0x15, 0x69, - 0x45, 0x93, 0xa6, 0x46, 0x7c, 0x5c, 0x63, 0xc6, 0xa6, 0xe6, 0xec, 0x56, 0x09, 0xf3, 0x30, 0xac, - 0x20, 0xe6, 0x9f, 0xfa, 0x1e, 0x82, 0x5e, 0xae, 0x11, 0x7e, 0xad, 0x80, 0x0b, 0xad, 0x17, 0x35, - 0x9c, 0x0c, 0x95, 0x11, 0xe7, 0x1e, 0xd4, 0xa9, 0x6e, 0x20, 0x62, 0xf9, 0x50, 0xfe, 0x89, 0x7b, - 0x05, 0x7e, 0xf2, 0xeb, 0xdf, 0x9f, 0xf7, 0x64, 0xe1, 0x98, 0x16, 0xed, 0xe9, 0x9a, 0x7c, 0x02, - 0xfc, 0x56, 0x01, 0xe7, 0x5b, 0x66, 0x84, 0xd7, 0x3b, 0x4e, 0xee, 0xd1, 0x9d, 0xec, 0x02, 0x21, - 0xd9, 0x2e, 0x71, 0xa2, 0xb3, 0xf0, 0x46, 0x47, 0x44, 0xb5, 0x7a, 0xd0, 0x0f, 0x36, 0xe0, 0xcf, - 0x0a, 0xb8, 0x1c, 0x71, 0x4d, 0xc3, 0xd9, 0x68, 0x3a, 0xf1, 0x86, 0x40, 0x9d, 0x3b, 0x06, 0x52, - 0x0a, 0x5a, 0xe4, 0x82, 0x66, 0xe0, 0x74, 0xa8, 0x20, 0x47, 0xa2, 0x75, 0xe6, 0xc2, 0x75, 0x71, - 0x70, 0xeb, 0xeb, 0xbb, 0xba, 0x69, 0x68, 0x75, 0xd3, 0x68, 0xc0, 0x3f, 0x14, 0xa0, 0x46, 0x5f, - 0xe3, 0x70, 0xa1, 0x4b, 0x62, 0xcd, 0xe6, 0x41, 0x7d, 0xf3, 0x78, 0x60, 0x29, 0xec, 0x16, 0x17, - 0xb6, 0x08, 0x17, 0xba, 0x13, 0xc6, 0x1d, 0x8a, 0x56, 0xe7, 0x1f, 0x0d, 0xf8, 0x9b, 0x02, 0x06, - 0x23, 0xef, 0x7c, 0x38, 0xdf, 0x15, 0xc1, 0x80, 0xcf, 0x50, 0x17, 0x8e, 0x85, 0x95, 0xda, 0xde, - 0xe2, 0xda, 0xe6, 0xe1, 0x6c, 0x17, 0xda, 0xdc, 0x83, 0xce, 0xd0, 0xea, 0xfc, 0xbc, 0x6b, 0xc0, - 0x1f, 0x15, 0x70, 0x39, 0xe2, 0xa2, 0x8f, 0xab, 0xc3, 0x78, 0x2f, 0x12, 0x57, 0x87, 0x6d, 0x5c, - 0x05, 0xca, 0x73, 0x49, 0xd7, 0xe0, 0x44, 0xe7, 0x92, 0x18, 0xdc, 0x53, 0xc0, 0x60, 0xe4, 0x55, - 0x1e, 0xb7, 0x3d, 0xed, 0x8c, 0x42, 0xdc, 0xf6, 0xb4, 0xf5, 0x0e, 0x68, 0x9e, 0x6b, 0x79, 0x03, - 0x4e, 0x85, 0x1f, 0x12, 0x98, 0x39, 0x7a, 0xf8, 0x1e, 0x99, 0x06, 0xfc, 0x85, 0x57, 0x5c, 0x84, - 0x75, 0x88, 0xaf, 0xb8, 0x78, 0x63, 0x12, 0x5f, 0x71, 0x6d, 0xbc, 0x0a, 0x9a, 0xe3, 0x92, 0xf2, - 0x70, 0x32, 0x62, 0x7b, 0x1c, 0x5c, 0x6e, 0xd1, 0x64, 0xe8, 0x58, 0x70, 0xfe, 0x42, 0x01, 0xfd, - 0x47, 0x1c, 0x09, 0x9c, 0x68, 0xc3, 0xa6, 0x39, 0x58, 0xcd, 0x77, 0x11, 0xec, 0x53, 0xbe, 0xce, - 0x29, 0x8f, 0xc3, 0x6c, 0x0c, 0x65, 0x79, 0x60, 0x33, 0xc1, 0xe9, 0x07, 0x05, 0xbc, 0x16, 0xee, - 0x80, 0xb4, 0x0e, 0xbb, 0xd5, 0x03, 0xa8, 0x33, 0x5d, 0x02, 0x7c, 0xd6, 0x37, 0x39, 0xeb, 0x39, - 0x38, 0xd3, 0x49, 0x1f, 0x94, 0x69, 0x71, 0x53, 0x37, 0xad, 0x0d, 0xaa, 0xd5, 0xa5, 0xa3, 0x69, - 0xc0, 0x4f, 0x15, 0xd0, 0x27, 0x7e, 0x61, 0xc2, 0x4c, 0x34, 0x89, 0xc0, 0xcf, 0x59, 0x35, 0xdb, - 0x3e, 0x50, 0xd2, 0xcb, 0x1e, 0xde, 0xd6, 0x57, 0xe0, 0x50, 0x28, 0x47, 0xf1, 0x5b, 0x16, 0xbe, - 0x08, 0x3f, 0x3a, 0x85, 0xe7, 0xe9, 0xf2, 0xe8, 0x0c, 0x98, 0xbc, 0x2e, 0x8f, 0xce, 0xa0, 0x5b, - 0x43, 0xef, 0x72, 0xee, 0xab, 0x70, 0x25, 0x94, 0x7b, 0x3d, 0x60, 0x0f, 0x1b, 0x11, 0x47, 0xa9, - 0x74, 0x6a, 0x2b, 0x37, 0x9f, 0xed, 0xa7, 0x94, 0xbd, 0xfd, 0x94, 0xf2, 0x62, 0x3f, 0xa5, 0x7c, - 0x76, 0x90, 0x4a, 0xec, 0x1d, 0xa4, 0x12, 0xbf, 0x1f, 0xa4, 0x12, 0x0f, 0x46, 0x8f, 0xda, 0x31, - 0x9e, 0xee, 0x91, 0x97, 0x90, 0x3b, 0xb2, 0xf5, 0x3e, 0xfe, 0x6f, 0xa5, 0xfc, 0xff, 0x01, 0x00, - 0x00, 0xff, 0xff, 0x18, 0xf5, 0xc3, 0x1b, 0x60, 0x13, 0x00, 0x00, + proto.RegisterType((*QueryLiquidValidatorRequest)(nil), "kyve.liquid.v1beta1.QueryLiquidValidatorRequest") + proto.RegisterType((*QueryLiquidValidatorResponse)(nil), "kyve.liquid.v1beta1.QueryLiquidValidatorResponse") + proto.RegisterType((*QueryLiquidValidatorsRequest)(nil), "kyve.liquid.v1beta1.QueryLiquidValidatorsRequest") + proto.RegisterType((*QueryLiquidValidatorsResponse)(nil), "kyve.liquid.v1beta1.QueryLiquidValidatorsResponse") + proto.RegisterType((*QueryParamsRequest)(nil), "kyve.liquid.v1beta1.QueryParamsRequest") + proto.RegisterType((*QueryParamsResponse)(nil), "kyve.liquid.v1beta1.QueryParamsResponse") + proto.RegisterType((*QueryTokenizeShareRecordByIdRequest)(nil), "kyve.liquid.v1beta1.QueryTokenizeShareRecordByIdRequest") + proto.RegisterType((*QueryTokenizeShareRecordByIdResponse)(nil), "kyve.liquid.v1beta1.QueryTokenizeShareRecordByIdResponse") + proto.RegisterType((*QueryTokenizeShareRecordByDenomRequest)(nil), "kyve.liquid.v1beta1.QueryTokenizeShareRecordByDenomRequest") + proto.RegisterType((*QueryTokenizeShareRecordByDenomResponse)(nil), "kyve.liquid.v1beta1.QueryTokenizeShareRecordByDenomResponse") + proto.RegisterType((*QueryTokenizeShareRecordsOwnedRequest)(nil), "kyve.liquid.v1beta1.QueryTokenizeShareRecordsOwnedRequest") + proto.RegisterType((*QueryTokenizeShareRecordsOwnedResponse)(nil), "kyve.liquid.v1beta1.QueryTokenizeShareRecordsOwnedResponse") + proto.RegisterType((*QueryAllTokenizeShareRecordsRequest)(nil), "kyve.liquid.v1beta1.QueryAllTokenizeShareRecordsRequest") + proto.RegisterType((*QueryAllTokenizeShareRecordsResponse)(nil), "kyve.liquid.v1beta1.QueryAllTokenizeShareRecordsResponse") + proto.RegisterType((*QueryLastTokenizeShareRecordIdRequest)(nil), "kyve.liquid.v1beta1.QueryLastTokenizeShareRecordIdRequest") + proto.RegisterType((*QueryLastTokenizeShareRecordIdResponse)(nil), "kyve.liquid.v1beta1.QueryLastTokenizeShareRecordIdResponse") + proto.RegisterType((*QueryTotalTokenizeSharedAssetsRequest)(nil), "kyve.liquid.v1beta1.QueryTotalTokenizeSharedAssetsRequest") + proto.RegisterType((*QueryTotalTokenizeSharedAssetsResponse)(nil), "kyve.liquid.v1beta1.QueryTotalTokenizeSharedAssetsResponse") + proto.RegisterType((*QueryTotalLiquidStaked)(nil), "kyve.liquid.v1beta1.QueryTotalLiquidStaked") + proto.RegisterType((*QueryTotalLiquidStakedResponse)(nil), "kyve.liquid.v1beta1.QueryTotalLiquidStakedResponse") + proto.RegisterType((*QueryTokenizeShareLockInfo)(nil), "kyve.liquid.v1beta1.QueryTokenizeShareLockInfo") + proto.RegisterType((*QueryTokenizeShareLockInfoResponse)(nil), "kyve.liquid.v1beta1.QueryTokenizeShareLockInfoResponse") + proto.RegisterType((*QueryTokenizeShareRecordRewardRequest)(nil), "kyve.liquid.v1beta1.QueryTokenizeShareRecordRewardRequest") + proto.RegisterType((*QueryTokenizeShareRecordRewardResponse)(nil), "kyve.liquid.v1beta1.QueryTokenizeShareRecordRewardResponse") +} + +func init() { proto.RegisterFile("kyve/liquid/v1beta1/query.proto", fileDescriptor_1a9d927347bb19fc) } + +var fileDescriptor_1a9d927347bb19fc = []byte{ + // 1341 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x58, 0xcd, 0x6f, 0x1b, 0xc5, + 0x1b, 0xf6, 0xe6, 0xd7, 0xa4, 0xbf, 0x0e, 0xf4, 0x6b, 0x1a, 0x5a, 0x77, 0xd3, 0xda, 0xd5, 0xd0, + 0xd6, 0x56, 0xa2, 0x7a, 0x9b, 0x98, 0x34, 0x5f, 0x24, 0x90, 0x34, 0x2d, 0x14, 0xa2, 0x52, 0xdc, + 0x52, 0x89, 0x0a, 0x69, 0x35, 0xf1, 0x4e, 0x9c, 0x95, 0xed, 0x1d, 0x67, 0x67, 0x9d, 0xd4, 0xb5, + 0x7c, 0x41, 0x42, 0xea, 0x11, 0x89, 0x7f, 0xa0, 0x37, 0x10, 0x07, 0xc4, 0x09, 0x89, 0x0b, 0x07, + 0x90, 0x50, 0x2f, 0x88, 0x48, 0x48, 0x88, 0x03, 0x2a, 0x25, 0x41, 0x82, 0x33, 0x7f, 0x01, 0xda, + 0x99, 0xd9, 0x8d, 0xd7, 0xdd, 0x5d, 0xdb, 0x51, 0x2e, 0xb1, 0x67, 0xe6, 0xfd, 0x78, 0x9e, 0x99, + 0xf7, 0x9d, 0x79, 0x1c, 0x90, 0x2e, 0x37, 0x36, 0x89, 0x56, 0x31, 0x37, 0xea, 0xa6, 0xa1, 0x6d, + 0x8e, 0xaf, 0x12, 0x07, 0x8f, 0x6b, 0x1b, 0x75, 0x62, 0x37, 0x72, 0x35, 0x9b, 0x3a, 0x14, 0x9e, + 0x72, 0x0d, 0x72, 0xc2, 0x20, 0x27, 0x0d, 0xd4, 0x93, 0xb8, 0x6a, 0x5a, 0x54, 0xe3, 0x7f, 0x85, + 0x9d, 0x3a, 0x5a, 0xa4, 0xac, 0x4a, 0x99, 0xb6, 0x8a, 0x19, 0x11, 0x01, 0xfc, 0x70, 0x35, 0x5c, + 0x32, 0x2d, 0xec, 0x98, 0xd4, 0x92, 0xb6, 0xa9, 0x76, 0x5b, 0xcf, 0xaa, 0x48, 0x4d, 0x6f, 0x7d, + 0x44, 0xae, 0x7b, 0x61, 0xda, 0x01, 0xa9, 0xc3, 0x25, 0x5a, 0xa2, 0xfc, 0xab, 0xe6, 0x7e, 0x93, + 0xb3, 0xe7, 0x4a, 0x94, 0x96, 0x2a, 0x44, 0xc3, 0x35, 0x53, 0xc3, 0x96, 0x45, 0x1d, 0x9e, 0x8f, + 0xc9, 0xd5, 0x0b, 0x61, 0x2c, 0x25, 0x27, 0x6e, 0x81, 0x96, 0xc1, 0xc8, 0xfb, 0x6e, 0x92, 0x15, + 0x3e, 0x79, 0x1f, 0x57, 0x4c, 0x03, 0x3b, 0xd4, 0x2e, 0x90, 0x8d, 0x3a, 0x61, 0x0e, 0xbc, 0x04, + 0x8e, 0x6d, 0x7a, 0x73, 0x3a, 0x36, 0x0c, 0x3b, 0xa9, 0x5c, 0x50, 0xb2, 0x47, 0x0a, 0x47, 0xfd, + 0xd9, 0x45, 0xc3, 0xb0, 0xd1, 0x23, 0x70, 0x2e, 0x3c, 0x0a, 0xab, 0x51, 0x8b, 0x11, 0xf8, 0x00, + 0x9c, 0x10, 0x59, 0x75, 0xdf, 0x8f, 0x07, 0x7a, 0x69, 0xe2, 0x62, 0x2e, 0x64, 0x9f, 0x73, 0x1d, + 0x71, 0x96, 0x8e, 0x3c, 0x7d, 0x96, 0x4e, 0x7c, 0xf1, 0xf7, 0xd7, 0xa3, 0x4a, 0xe1, 0x78, 0x25, + 0xb8, 0x86, 0xd6, 0xc2, 0x73, 0x33, 0x8f, 0xc2, 0x4d, 0x00, 0xf6, 0x0e, 0x42, 0x66, 0xbd, 0x9c, + 0x13, 0x3b, 0x9d, 0x73, 0x4f, 0x22, 0x27, 0x76, 0xd9, 0xcb, 0x7d, 0x07, 0x97, 0x88, 0xf4, 0x2d, + 0xb4, 0x79, 0xa2, 0x1f, 0x15, 0x70, 0x3e, 0x22, 0x91, 0x64, 0xf9, 0x11, 0x38, 0xd9, 0xc9, 0x92, + 0x25, 0x95, 0x0b, 0xff, 0xdb, 0x0f, 0xcd, 0x13, 0x1d, 0x34, 0x19, 0x7c, 0x2b, 0xc0, 0x63, 0x80, + 0xf3, 0xc8, 0x74, 0xe5, 0x21, 0xa0, 0x05, 0x88, 0x0c, 0x03, 0xc8, 0x79, 0xdc, 0xc1, 0x36, 0xae, + 0x7a, 0xdb, 0x84, 0x3e, 0x00, 0xa7, 0x02, 0xb3, 0x92, 0xd3, 0x02, 0x18, 0xaa, 0xf1, 0x19, 0xb9, + 0x73, 0x23, 0xa1, 0x44, 0x84, 0x53, 0x3b, 0x7e, 0xe9, 0x85, 0x26, 0xc1, 0xab, 0x3c, 0xec, 0x3d, + 0x5a, 0x26, 0x96, 0xf9, 0x88, 0xdc, 0x5d, 0xc7, 0x36, 0x29, 0x90, 0x22, 0xb5, 0x8d, 0xa5, 0xc6, + 0x2d, 0xc3, 0x3b, 0xa4, 0x63, 0x60, 0xc0, 0x34, 0x78, 0x8a, 0x43, 0x85, 0x01, 0xd3, 0x40, 0x16, + 0xb8, 0x18, 0xef, 0x26, 0xe1, 0xdd, 0x04, 0x43, 0x36, 0x9f, 0x95, 0xf0, 0xb2, 0xa1, 0xf0, 0xc2, + 0xa2, 0x1c, 0x72, 0xb1, 0x16, 0xa4, 0x37, 0x5a, 0x00, 0x97, 0xa3, 0xf3, 0x2d, 0x13, 0x8b, 0x56, + 0x3d, 0xa4, 0xc3, 0x60, 0xd0, 0x70, 0xc7, 0xb2, 0x11, 0xc4, 0x00, 0x6d, 0x80, 0x4c, 0x57, 0xff, + 0x03, 0x86, 0x3c, 0x0f, 0x2e, 0x45, 0xa5, 0x64, 0xef, 0x6d, 0x59, 0xc4, 0x68, 0x43, 0x4c, 0xb7, + 0x2c, 0xe2, 0xb5, 0xae, 0x18, 0x20, 0x3b, 0x9a, 0xb1, 0xe7, 0x2e, 0x01, 0xbf, 0x0d, 0x0e, 0x8b, + 0x94, 0x5e, 0x31, 0xf7, 0x8b, 0xd8, 0x73, 0x47, 0x55, 0x59, 0x0c, 0x8b, 0x95, 0x4a, 0x58, 0xda, + 0x83, 0xee, 0xd8, 0x6f, 0x15, 0x59, 0x45, 0x91, 0xf9, 0x0e, 0x9a, 0xe1, 0xc1, 0x35, 0x69, 0x46, + 0x9e, 0xee, 0x0a, 0x66, 0x4e, 0x48, 0x5e, 0xbf, 0x73, 0xd0, 0xb4, 0x3c, 0xc7, 0x18, 0x43, 0xc9, + 0xb2, 0xb3, 0xc7, 0x32, 0x7e, 0x01, 0x39, 0x38, 0xb8, 0x3f, 0xc6, 0x22, 0x63, 0xc4, 0xf1, 0xaf, + 0x06, 0xdd, 0x2f, 0x95, 0x48, 0x43, 0x99, 0x62, 0x12, 0x0c, 0x6e, 0xe2, 0x4a, 0x9d, 0xc8, 0x43, + 0x3b, 0x1b, 0x60, 0xee, 0x71, 0xbe, 0x4e, 0x4d, 0x4b, 0xee, 0x9b, 0xb0, 0x46, 0x49, 0x70, 0x7a, + 0x2f, 0x81, 0xb8, 0x14, 0xef, 0x3a, 0xb8, 0x4c, 0x0c, 0x34, 0x0d, 0x52, 0xe1, 0x2b, 0x7e, 0xca, + 0xd3, 0x60, 0xc8, 0x71, 0x21, 0x31, 0x59, 0xde, 0x72, 0x84, 0xae, 0x01, 0xf5, 0xc5, 0xfa, 0x5e, + 0xa1, 0xc5, 0xf2, 0x2d, 0x6b, 0x8d, 0xc2, 0x24, 0x38, 0xec, 0xbe, 0x66, 0x84, 0x79, 0x6e, 0xde, + 0x10, 0x11, 0x80, 0xa2, 0xfd, 0xda, 0xb3, 0x32, 0x07, 0x3b, 0x75, 0x3f, 0xab, 0x18, 0xc1, 0x0c, + 0x38, 0x4e, 0x1e, 0xd6, 0x4c, 0x9b, 0x1f, 0xa2, 0xee, 0x98, 0x55, 0xc2, 0x8b, 0xe0, 0x48, 0xe1, + 0xd8, 0xde, 0xf4, 0x3d, 0xb3, 0x4a, 0x50, 0x2d, 0xba, 0x7b, 0x0b, 0x64, 0x0b, 0xdb, 0x7e, 0xf7, + 0xce, 0x83, 0xa3, 0xbc, 0x61, 0xf5, 0x00, 0xde, 0xa5, 0xe4, 0xbf, 0xcf, 0xd2, 0xc3, 0x0d, 0x5c, + 0xad, 0xcc, 0xa2, 0xc0, 0x32, 0x2a, 0xbc, 0xcc, 0xc7, 0x8b, 0x62, 0x38, 0xfb, 0xff, 0xc7, 0x4f, + 0xd2, 0x89, 0x7f, 0x9e, 0xa4, 0x13, 0xe8, 0x4f, 0x25, 0xba, 0xe3, 0xbd, 0x94, 0x92, 0xdd, 0x6d, + 0xb7, 0x1f, 0xdc, 0x19, 0xaf, 0x1f, 0x72, 0xbd, 0xf6, 0x83, 0x08, 0xb4, 0xd7, 0x15, 0x3c, 0x08, + 0x2c, 0x81, 0x41, 0xc7, 0x3d, 0xc0, 0xe4, 0x00, 0x8f, 0x76, 0x2e, 0xb4, 0x2c, 0x96, 0x49, 0x91, + 0x57, 0x46, 0xde, 0xf5, 0xfd, 0xf2, 0x8f, 0xf4, 0x58, 0xc9, 0x74, 0xd6, 0xeb, 0xab, 0xb9, 0x22, + 0xad, 0x6a, 0x52, 0x17, 0x89, 0x8f, 0x2b, 0xcc, 0x28, 0x6b, 0x4e, 0xa3, 0x46, 0x98, 0xe7, 0xc3, + 0x0a, 0x22, 0xfe, 0xc4, 0x77, 0x10, 0x0c, 0x72, 0x8e, 0xf0, 0x2b, 0x05, 0x9c, 0xe8, 0x7c, 0xa8, + 0xe1, 0x78, 0x28, 0x8d, 0x38, 0xf5, 0xa0, 0x4e, 0xf4, 0xe3, 0x22, 0xb6, 0x0f, 0xe5, 0x1f, 0xbb, + 0x4f, 0xe0, 0xc7, 0xbf, 0xfc, 0xf5, 0xd9, 0x40, 0x16, 0x5e, 0xd6, 0x4a, 0xd8, 0xc4, 0xe1, 0x1a, + 0xac, 0x4d, 0x27, 0xc0, 0x6f, 0x14, 0x70, 0xbc, 0x23, 0x22, 0xbc, 0xda, 0x73, 0x72, 0x0f, 0xee, + 0x78, 0x1f, 0x1e, 0x12, 0xed, 0x02, 0x07, 0x3a, 0x0d, 0xaf, 0xf5, 0x04, 0x54, 0x6b, 0x06, 0xf5, + 0x60, 0x0b, 0xfe, 0xa4, 0x80, 0x33, 0x11, 0xcf, 0x34, 0x9c, 0x8e, 0x86, 0x13, 0x2f, 0x08, 0xd4, + 0x99, 0x7d, 0x78, 0x4a, 0x42, 0xf3, 0x9c, 0xd0, 0x14, 0x9c, 0x0c, 0x25, 0xe4, 0x48, 0x6f, 0x9d, + 0xb9, 0xee, 0xba, 0xb8, 0xb8, 0xf5, 0xd5, 0x86, 0x6e, 0x1a, 0x5a, 0xd3, 0x34, 0x5a, 0xf0, 0x77, + 0x05, 0xa8, 0xd1, 0xcf, 0x38, 0x9c, 0xeb, 0x13, 0x58, 0xbb, 0x78, 0x50, 0x5f, 0xdf, 0x9f, 0xb3, + 0x24, 0x76, 0x9d, 0x13, 0x9b, 0x87, 0x73, 0xfd, 0x11, 0xe3, 0x0a, 0x45, 0x6b, 0xf2, 0x8f, 0x16, + 0xfc, 0x55, 0x01, 0x67, 0x23, 0xdf, 0x7c, 0x38, 0xdb, 0x17, 0xc0, 0x80, 0xce, 0x50, 0xe7, 0xf6, + 0xe5, 0x2b, 0xb9, 0xbd, 0xc9, 0xb9, 0xcd, 0xc2, 0xe9, 0x3e, 0xb8, 0xb9, 0x17, 0x9d, 0xa1, 0x35, + 0xf9, 0x7d, 0xd7, 0x82, 0x3f, 0x28, 0xe0, 0x4c, 0xc4, 0x43, 0x1f, 0x57, 0x87, 0xf1, 0x5a, 0x24, + 0xae, 0x0e, 0xbb, 0xa8, 0x0a, 0x94, 0xe7, 0x94, 0xae, 0xc0, 0xb1, 0xde, 0x29, 0x31, 0xb8, 0xad, + 0x80, 0xb3, 0x91, 0x4f, 0x79, 0xdc, 0xf1, 0x74, 0x13, 0x0a, 0x71, 0xc7, 0xd3, 0x55, 0x3b, 0xa0, + 0x59, 0xce, 0xe5, 0x35, 0x38, 0x11, 0x7e, 0x49, 0x60, 0xe6, 0xe8, 0xe1, 0x67, 0x64, 0x1a, 0xf0, + 0x67, 0x5e, 0x71, 0x11, 0xd2, 0x21, 0xbe, 0xe2, 0xe2, 0x85, 0x49, 0x7c, 0xc5, 0x75, 0xd1, 0x2a, + 0x68, 0x86, 0x53, 0xca, 0xc3, 0xf1, 0x88, 0xe3, 0x71, 0x70, 0xa5, 0x83, 0x93, 0xa1, 0x63, 0x81, + 0xf9, 0x73, 0x05, 0x9c, 0x7c, 0x41, 0x91, 0xc0, 0xb1, 0x2e, 0x68, 0xda, 0x8d, 0xd5, 0x7c, 0x1f, + 0xc6, 0x3e, 0xe4, 0xab, 0x1c, 0xf2, 0x28, 0xcc, 0xc6, 0x40, 0x96, 0x17, 0x36, 0x13, 0x98, 0xbe, + 0x57, 0xc0, 0x2b, 0xe1, 0x0a, 0x48, 0xeb, 0xb1, 0x5b, 0x3d, 0x07, 0x75, 0xaa, 0x4f, 0x07, 0x1f, + 0xf5, 0x1b, 0x1c, 0xf5, 0x0c, 0x9c, 0xea, 0xa5, 0x0f, 0x2a, 0xb4, 0x58, 0xd6, 0x4d, 0x6b, 0x8d, + 0x6a, 0x4d, 0xa9, 0x68, 0x5a, 0xf0, 0x13, 0x05, 0x0c, 0x89, 0x5f, 0x98, 0x30, 0x13, 0x0d, 0x22, + 0xf0, 0x73, 0x56, 0xcd, 0x76, 0x37, 0x94, 0xf0, 0xb2, 0x7b, 0xaf, 0xf5, 0x79, 0x38, 0x12, 0x8a, + 0x51, 0xfc, 0x96, 0x85, 0xcf, 0xc3, 0xaf, 0x4e, 0xa1, 0x79, 0xfa, 0xbc, 0x3a, 0x03, 0x22, 0xaf, + 0xcf, 0xab, 0x33, 0xa8, 0xd6, 0xd0, 0x3b, 0x1c, 0xfb, 0x32, 0x5c, 0x0a, 0xc5, 0xde, 0x0c, 0xc8, + 0xc3, 0x56, 0xc4, 0x55, 0x2a, 0x95, 0xda, 0xd2, 0x8d, 0xa7, 0x3b, 0x29, 0x65, 0x7b, 0x27, 0xa5, + 0x3c, 0xdf, 0x49, 0x29, 0x9f, 0xee, 0xa6, 0x12, 0xdb, 0xbb, 0xa9, 0xc4, 0x6f, 0xbb, 0xa9, 0xc4, + 0x83, 0x76, 0x39, 0xf6, 0xee, 0x87, 0xf7, 0x6f, 0xdc, 0x26, 0xce, 0x16, 0xb5, 0xcb, 0x5a, 0x71, + 0x1d, 0x9b, 0x96, 0xf6, 0xd0, 0x4b, 0xcb, 0x75, 0xd9, 0xea, 0x10, 0xff, 0xe7, 0x52, 0xfe, 0xbf, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xe4, 0x7e, 0xa8, 0xd8, 0x66, 0x13, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -1315,7 +1316,7 @@ func NewQueryClient(cc grpc1.ClientConn) QueryClient { func (c *queryClient) LiquidValidators(ctx context.Context, in *QueryLiquidValidatorsRequest, opts ...grpc.CallOption) (*QueryLiquidValidatorsResponse, error) { out := new(QueryLiquidValidatorsResponse) - err := c.cc.Invoke(ctx, "/gaia.liquid.v1beta1.Query/LiquidValidators", in, out, opts...) + err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Query/LiquidValidators", in, out, opts...) if err != nil { return nil, err } @@ -1324,7 +1325,7 @@ func (c *queryClient) LiquidValidators(ctx context.Context, in *QueryLiquidValid func (c *queryClient) LiquidValidator(ctx context.Context, in *QueryLiquidValidatorRequest, opts ...grpc.CallOption) (*QueryLiquidValidatorResponse, error) { out := new(QueryLiquidValidatorResponse) - err := c.cc.Invoke(ctx, "/gaia.liquid.v1beta1.Query/LiquidValidator", in, out, opts...) + err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Query/LiquidValidator", in, out, opts...) if err != nil { return nil, err } @@ -1333,7 +1334,7 @@ func (c *queryClient) LiquidValidator(ctx context.Context, in *QueryLiquidValida func (c *queryClient) TokenizeShareRecordById(ctx context.Context, in *QueryTokenizeShareRecordByIdRequest, opts ...grpc.CallOption) (*QueryTokenizeShareRecordByIdResponse, error) { out := new(QueryTokenizeShareRecordByIdResponse) - err := c.cc.Invoke(ctx, "/gaia.liquid.v1beta1.Query/TokenizeShareRecordById", in, out, opts...) + err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Query/TokenizeShareRecordById", in, out, opts...) if err != nil { return nil, err } @@ -1342,7 +1343,7 @@ func (c *queryClient) TokenizeShareRecordById(ctx context.Context, in *QueryToke func (c *queryClient) TokenizeShareRecordByDenom(ctx context.Context, in *QueryTokenizeShareRecordByDenomRequest, opts ...grpc.CallOption) (*QueryTokenizeShareRecordByDenomResponse, error) { out := new(QueryTokenizeShareRecordByDenomResponse) - err := c.cc.Invoke(ctx, "/gaia.liquid.v1beta1.Query/TokenizeShareRecordByDenom", in, out, opts...) + err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Query/TokenizeShareRecordByDenom", in, out, opts...) if err != nil { return nil, err } @@ -1351,7 +1352,7 @@ func (c *queryClient) TokenizeShareRecordByDenom(ctx context.Context, in *QueryT func (c *queryClient) TokenizeShareRecordsOwned(ctx context.Context, in *QueryTokenizeShareRecordsOwnedRequest, opts ...grpc.CallOption) (*QueryTokenizeShareRecordsOwnedResponse, error) { out := new(QueryTokenizeShareRecordsOwnedResponse) - err := c.cc.Invoke(ctx, "/gaia.liquid.v1beta1.Query/TokenizeShareRecordsOwned", in, out, opts...) + err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Query/TokenizeShareRecordsOwned", in, out, opts...) if err != nil { return nil, err } @@ -1360,7 +1361,7 @@ func (c *queryClient) TokenizeShareRecordsOwned(ctx context.Context, in *QueryTo func (c *queryClient) AllTokenizeShareRecords(ctx context.Context, in *QueryAllTokenizeShareRecordsRequest, opts ...grpc.CallOption) (*QueryAllTokenizeShareRecordsResponse, error) { out := new(QueryAllTokenizeShareRecordsResponse) - err := c.cc.Invoke(ctx, "/gaia.liquid.v1beta1.Query/AllTokenizeShareRecords", in, out, opts...) + err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Query/AllTokenizeShareRecords", in, out, opts...) if err != nil { return nil, err } @@ -1369,7 +1370,7 @@ func (c *queryClient) AllTokenizeShareRecords(ctx context.Context, in *QueryAllT func (c *queryClient) LastTokenizeShareRecordId(ctx context.Context, in *QueryLastTokenizeShareRecordIdRequest, opts ...grpc.CallOption) (*QueryLastTokenizeShareRecordIdResponse, error) { out := new(QueryLastTokenizeShareRecordIdResponse) - err := c.cc.Invoke(ctx, "/gaia.liquid.v1beta1.Query/LastTokenizeShareRecordId", in, out, opts...) + err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Query/LastTokenizeShareRecordId", in, out, opts...) if err != nil { return nil, err } @@ -1378,7 +1379,7 @@ func (c *queryClient) LastTokenizeShareRecordId(ctx context.Context, in *QueryLa func (c *queryClient) TotalTokenizeSharedAssets(ctx context.Context, in *QueryTotalTokenizeSharedAssetsRequest, opts ...grpc.CallOption) (*QueryTotalTokenizeSharedAssetsResponse, error) { out := new(QueryTotalTokenizeSharedAssetsResponse) - err := c.cc.Invoke(ctx, "/gaia.liquid.v1beta1.Query/TotalTokenizeSharedAssets", in, out, opts...) + err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Query/TotalTokenizeSharedAssets", in, out, opts...) if err != nil { return nil, err } @@ -1387,7 +1388,7 @@ func (c *queryClient) TotalTokenizeSharedAssets(ctx context.Context, in *QueryTo func (c *queryClient) TotalLiquidStaked(ctx context.Context, in *QueryTotalLiquidStaked, opts ...grpc.CallOption) (*QueryTotalLiquidStakedResponse, error) { out := new(QueryTotalLiquidStakedResponse) - err := c.cc.Invoke(ctx, "/gaia.liquid.v1beta1.Query/TotalLiquidStaked", in, out, opts...) + err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Query/TotalLiquidStaked", in, out, opts...) if err != nil { return nil, err } @@ -1396,7 +1397,7 @@ func (c *queryClient) TotalLiquidStaked(ctx context.Context, in *QueryTotalLiqui func (c *queryClient) TokenizeShareLockInfo(ctx context.Context, in *QueryTokenizeShareLockInfo, opts ...grpc.CallOption) (*QueryTokenizeShareLockInfoResponse, error) { out := new(QueryTokenizeShareLockInfoResponse) - err := c.cc.Invoke(ctx, "/gaia.liquid.v1beta1.Query/TokenizeShareLockInfo", in, out, opts...) + err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Query/TokenizeShareLockInfo", in, out, opts...) if err != nil { return nil, err } @@ -1405,7 +1406,7 @@ func (c *queryClient) TokenizeShareLockInfo(ctx context.Context, in *QueryTokeni func (c *queryClient) Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error) { out := new(QueryParamsResponse) - err := c.cc.Invoke(ctx, "/gaia.liquid.v1beta1.Query/Params", in, out, opts...) + err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Query/Params", in, out, opts...) if err != nil { return nil, err } @@ -1414,7 +1415,7 @@ func (c *queryClient) Params(ctx context.Context, in *QueryParamsRequest, opts . func (c *queryClient) TokenizeShareRecordReward(ctx context.Context, in *QueryTokenizeShareRecordRewardRequest, opts ...grpc.CallOption) (*QueryTokenizeShareRecordRewardResponse, error) { out := new(QueryTokenizeShareRecordRewardResponse) - err := c.cc.Invoke(ctx, "/gaia.liquid.v1beta1.Query/TokenizeShareRecordReward", in, out, opts...) + err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Query/TokenizeShareRecordReward", in, out, opts...) if err != nil { return nil, err } @@ -1508,7 +1509,7 @@ func _Query_LiquidValidators_Handler(srv interface{}, ctx context.Context, dec f } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/gaia.liquid.v1beta1.Query/LiquidValidators", + FullMethod: "/kyve.liquid.v1beta1.Query/LiquidValidators", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(QueryServer).LiquidValidators(ctx, req.(*QueryLiquidValidatorsRequest)) @@ -1526,7 +1527,7 @@ func _Query_LiquidValidator_Handler(srv interface{}, ctx context.Context, dec fu } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/gaia.liquid.v1beta1.Query/LiquidValidator", + FullMethod: "/kyve.liquid.v1beta1.Query/LiquidValidator", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(QueryServer).LiquidValidator(ctx, req.(*QueryLiquidValidatorRequest)) @@ -1544,7 +1545,7 @@ func _Query_TokenizeShareRecordById_Handler(srv interface{}, ctx context.Context } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/gaia.liquid.v1beta1.Query/TokenizeShareRecordById", + FullMethod: "/kyve.liquid.v1beta1.Query/TokenizeShareRecordById", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(QueryServer).TokenizeShareRecordById(ctx, req.(*QueryTokenizeShareRecordByIdRequest)) @@ -1562,7 +1563,7 @@ func _Query_TokenizeShareRecordByDenom_Handler(srv interface{}, ctx context.Cont } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/gaia.liquid.v1beta1.Query/TokenizeShareRecordByDenom", + FullMethod: "/kyve.liquid.v1beta1.Query/TokenizeShareRecordByDenom", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(QueryServer).TokenizeShareRecordByDenom(ctx, req.(*QueryTokenizeShareRecordByDenomRequest)) @@ -1580,7 +1581,7 @@ func _Query_TokenizeShareRecordsOwned_Handler(srv interface{}, ctx context.Conte } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/gaia.liquid.v1beta1.Query/TokenizeShareRecordsOwned", + FullMethod: "/kyve.liquid.v1beta1.Query/TokenizeShareRecordsOwned", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(QueryServer).TokenizeShareRecordsOwned(ctx, req.(*QueryTokenizeShareRecordsOwnedRequest)) @@ -1598,7 +1599,7 @@ func _Query_AllTokenizeShareRecords_Handler(srv interface{}, ctx context.Context } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/gaia.liquid.v1beta1.Query/AllTokenizeShareRecords", + FullMethod: "/kyve.liquid.v1beta1.Query/AllTokenizeShareRecords", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(QueryServer).AllTokenizeShareRecords(ctx, req.(*QueryAllTokenizeShareRecordsRequest)) @@ -1616,7 +1617,7 @@ func _Query_LastTokenizeShareRecordId_Handler(srv interface{}, ctx context.Conte } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/gaia.liquid.v1beta1.Query/LastTokenizeShareRecordId", + FullMethod: "/kyve.liquid.v1beta1.Query/LastTokenizeShareRecordId", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(QueryServer).LastTokenizeShareRecordId(ctx, req.(*QueryLastTokenizeShareRecordIdRequest)) @@ -1634,7 +1635,7 @@ func _Query_TotalTokenizeSharedAssets_Handler(srv interface{}, ctx context.Conte } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/gaia.liquid.v1beta1.Query/TotalTokenizeSharedAssets", + FullMethod: "/kyve.liquid.v1beta1.Query/TotalTokenizeSharedAssets", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(QueryServer).TotalTokenizeSharedAssets(ctx, req.(*QueryTotalTokenizeSharedAssetsRequest)) @@ -1652,7 +1653,7 @@ func _Query_TotalLiquidStaked_Handler(srv interface{}, ctx context.Context, dec } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/gaia.liquid.v1beta1.Query/TotalLiquidStaked", + FullMethod: "/kyve.liquid.v1beta1.Query/TotalLiquidStaked", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(QueryServer).TotalLiquidStaked(ctx, req.(*QueryTotalLiquidStaked)) @@ -1670,7 +1671,7 @@ func _Query_TokenizeShareLockInfo_Handler(srv interface{}, ctx context.Context, } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/gaia.liquid.v1beta1.Query/TokenizeShareLockInfo", + FullMethod: "/kyve.liquid.v1beta1.Query/TokenizeShareLockInfo", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(QueryServer).TokenizeShareLockInfo(ctx, req.(*QueryTokenizeShareLockInfo)) @@ -1688,7 +1689,7 @@ func _Query_Params_Handler(srv interface{}, ctx context.Context, dec func(interf } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/gaia.liquid.v1beta1.Query/Params", + FullMethod: "/kyve.liquid.v1beta1.Query/Params", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(QueryServer).Params(ctx, req.(*QueryParamsRequest)) @@ -1706,7 +1707,7 @@ func _Query_TokenizeShareRecordReward_Handler(srv interface{}, ctx context.Conte } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/gaia.liquid.v1beta1.Query/TokenizeShareRecordReward", + FullMethod: "/kyve.liquid.v1beta1.Query/TokenizeShareRecordReward", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(QueryServer).TokenizeShareRecordReward(ctx, req.(*QueryTokenizeShareRecordRewardRequest)) @@ -1716,7 +1717,7 @@ func _Query_TokenizeShareRecordReward_Handler(srv interface{}, ctx context.Conte var Query_serviceDesc = _Query_serviceDesc var _Query_serviceDesc = grpc.ServiceDesc{ - ServiceName: "gaia.liquid.v1beta1.Query", + ServiceName: "kyve.liquid.v1beta1.Query", HandlerType: (*QueryServer)(nil), Methods: []grpc.MethodDesc{ { @@ -1769,7 +1770,7 @@ var _Query_serviceDesc = grpc.ServiceDesc{ }, }, Streams: []grpc.StreamDesc{}, - Metadata: "gaia/liquid/v1beta1/query.proto", + Metadata: "kyve/liquid/v1beta1/query.proto", } func (m *QueryLiquidValidatorRequest) Marshal() (dAtA []byte, err error) { diff --git a/x/liquid/types/query.pb.gw.go b/x/liquid/types/query.pb.gw.go index b371995e..41b6ec20 100644 --- a/x/liquid/types/query.pb.gw.go +++ b/x/liquid/types/query.pb.gw.go @@ -1,5 +1,5 @@ // Code generated by protoc-gen-grpc-gateway. DO NOT EDIT. -// source: gaia/liquid/v1beta1/query.proto +// source: kyve/liquid/v1beta1/query.proto /* Package types is a reverse proxy. @@ -1068,29 +1068,29 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie } var ( - pattern_Query_LiquidValidators_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gaia", "liquid", "v1beta1", "liquid_validators"}, "", runtime.AssumeColonVerbOpt(false))) + pattern_Query_LiquidValidators_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gaia", "liquid", "v1beta1", "liquid_validators"}, "", runtime.AssumeColonVerbOpt(true))) - pattern_Query_LiquidValidator_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"gaia", "liquid", "v1beta1", "liquid_validator", "validator_addr"}, "", runtime.AssumeColonVerbOpt(false))) + pattern_Query_LiquidValidator_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"gaia", "liquid", "v1beta1", "liquid_validator", "validator_addr"}, "", runtime.AssumeColonVerbOpt(true))) - pattern_Query_TokenizeShareRecordById_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"gaia", "liquid", "v1beta1", "tokenize_share_record_by_id", "id"}, "", runtime.AssumeColonVerbOpt(false))) + pattern_Query_TokenizeShareRecordById_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"gaia", "liquid", "v1beta1", "tokenize_share_record_by_id", "id"}, "", runtime.AssumeColonVerbOpt(true))) - pattern_Query_TokenizeShareRecordByDenom_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"gaia", "liquid", "v1beta1", "tokenize_share_record_by_denom", "denom"}, "", runtime.AssumeColonVerbOpt(false))) + pattern_Query_TokenizeShareRecordByDenom_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"gaia", "liquid", "v1beta1", "tokenize_share_record_by_denom", "denom"}, "", runtime.AssumeColonVerbOpt(true))) - pattern_Query_TokenizeShareRecordsOwned_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"gaia", "liquid", "v1beta1", "tokenize_share_record_owned", "owner"}, "", runtime.AssumeColonVerbOpt(false))) + pattern_Query_TokenizeShareRecordsOwned_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"gaia", "liquid", "v1beta1", "tokenize_share_record_owned", "owner"}, "", runtime.AssumeColonVerbOpt(true))) - pattern_Query_AllTokenizeShareRecords_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gaia", "liquid", "v1beta1", "tokenize_share_records"}, "", runtime.AssumeColonVerbOpt(false))) + pattern_Query_AllTokenizeShareRecords_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gaia", "liquid", "v1beta1", "tokenize_share_records"}, "", runtime.AssumeColonVerbOpt(true))) - pattern_Query_LastTokenizeShareRecordId_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gaia", "liquid", "v1beta1", "last_tokenize_share_record_id"}, "", runtime.AssumeColonVerbOpt(false))) + pattern_Query_LastTokenizeShareRecordId_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gaia", "liquid", "v1beta1", "last_tokenize_share_record_id"}, "", runtime.AssumeColonVerbOpt(true))) - pattern_Query_TotalTokenizeSharedAssets_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gaia", "liquid", "v1beta1", "total_tokenize_shared_assets"}, "", runtime.AssumeColonVerbOpt(false))) + pattern_Query_TotalTokenizeSharedAssets_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gaia", "liquid", "v1beta1", "total_tokenize_shared_assets"}, "", runtime.AssumeColonVerbOpt(true))) - pattern_Query_TotalLiquidStaked_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gaia", "liquid", "v1beta1", "total_liquid_staked"}, "", runtime.AssumeColonVerbOpt(false))) + pattern_Query_TotalLiquidStaked_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gaia", "liquid", "v1beta1", "total_liquid_staked"}, "", runtime.AssumeColonVerbOpt(true))) - pattern_Query_TokenizeShareLockInfo_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"gaia", "liquid", "v1beta1", "tokenize_share_lock_info", "address"}, "", runtime.AssumeColonVerbOpt(false))) + pattern_Query_TokenizeShareLockInfo_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"gaia", "liquid", "v1beta1", "tokenize_share_lock_info", "address"}, "", runtime.AssumeColonVerbOpt(true))) - pattern_Query_Params_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gaia", "liquid", "v1beta1", "params"}, "", runtime.AssumeColonVerbOpt(false))) + pattern_Query_Params_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gaia", "liquid", "v1beta1", "params"}, "", runtime.AssumeColonVerbOpt(true))) - pattern_Query_TokenizeShareRecordReward_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 2, 4}, []string{"gaia", "liquid", "v1beta1", "owner_address", "tokenize_share_record_rewards"}, "", runtime.AssumeColonVerbOpt(false))) + pattern_Query_TokenizeShareRecordReward_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 2, 4}, []string{"gaia", "liquid", "v1beta1", "owner_address", "tokenize_share_record_rewards"}, "", runtime.AssumeColonVerbOpt(true))) ) var ( diff --git a/x/liquid/types/tx.pb.go b/x/liquid/types/tx.pb.go index 5581f756..50ba4345 100644 --- a/x/liquid/types/tx.pb.go +++ b/x/liquid/types/tx.pb.go @@ -1,5 +1,5 @@ // Code generated by protoc-gen-gogo. DO NOT EDIT. -// source: gaia/liquid/v1beta1/tx.proto +// source: kyve/liquid/v1beta1/tx.proto package types @@ -51,7 +51,7 @@ func (m *MsgUpdateParams) Reset() { *m = MsgUpdateParams{} } func (m *MsgUpdateParams) String() string { return proto.CompactTextString(m) } func (*MsgUpdateParams) ProtoMessage() {} func (*MsgUpdateParams) Descriptor() ([]byte, []int) { - return fileDescriptor_e504a27354d32365, []int{0} + return fileDescriptor_a63931950704005e, []int{0} } func (m *MsgUpdateParams) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -103,7 +103,7 @@ func (m *MsgUpdateParamsResponse) Reset() { *m = MsgUpdateParamsResponse func (m *MsgUpdateParamsResponse) String() string { return proto.CompactTextString(m) } func (*MsgUpdateParamsResponse) ProtoMessage() {} func (*MsgUpdateParamsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_e504a27354d32365, []int{1} + return fileDescriptor_a63931950704005e, []int{1} } func (m *MsgUpdateParamsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -144,7 +144,7 @@ func (m *MsgTokenizeShares) Reset() { *m = MsgTokenizeShares{} } func (m *MsgTokenizeShares) String() string { return proto.CompactTextString(m) } func (*MsgTokenizeShares) ProtoMessage() {} func (*MsgTokenizeShares) Descriptor() ([]byte, []int) { - return fileDescriptor_e504a27354d32365, []int{2} + return fileDescriptor_a63931950704005e, []int{2} } func (m *MsgTokenizeShares) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -182,7 +182,7 @@ func (m *MsgTokenizeSharesResponse) Reset() { *m = MsgTokenizeSharesResp func (m *MsgTokenizeSharesResponse) String() string { return proto.CompactTextString(m) } func (*MsgTokenizeSharesResponse) ProtoMessage() {} func (*MsgTokenizeSharesResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_e504a27354d32365, []int{3} + return fileDescriptor_a63931950704005e, []int{3} } func (m *MsgTokenizeSharesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -229,7 +229,7 @@ func (m *MsgRedeemTokensForShares) Reset() { *m = MsgRedeemTokensForShar func (m *MsgRedeemTokensForShares) String() string { return proto.CompactTextString(m) } func (*MsgRedeemTokensForShares) ProtoMessage() {} func (*MsgRedeemTokensForShares) Descriptor() ([]byte, []int) { - return fileDescriptor_e504a27354d32365, []int{4} + return fileDescriptor_a63931950704005e, []int{4} } func (m *MsgRedeemTokensForShares) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -268,7 +268,7 @@ func (m *MsgRedeemTokensForSharesResponse) Reset() { *m = MsgRedeemToken func (m *MsgRedeemTokensForSharesResponse) String() string { return proto.CompactTextString(m) } func (*MsgRedeemTokensForSharesResponse) ProtoMessage() {} func (*MsgRedeemTokensForSharesResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_e504a27354d32365, []int{5} + return fileDescriptor_a63931950704005e, []int{5} } func (m *MsgRedeemTokensForSharesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -315,7 +315,7 @@ func (m *MsgTransferTokenizeShareRecord) Reset() { *m = MsgTransferToken func (m *MsgTransferTokenizeShareRecord) String() string { return proto.CompactTextString(m) } func (*MsgTransferTokenizeShareRecord) ProtoMessage() {} func (*MsgTransferTokenizeShareRecord) Descriptor() ([]byte, []int) { - return fileDescriptor_e504a27354d32365, []int{6} + return fileDescriptor_a63931950704005e, []int{6} } func (m *MsgTransferTokenizeShareRecord) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -355,7 +355,7 @@ func (m *MsgTransferTokenizeShareRecordResponse) Reset() { func (m *MsgTransferTokenizeShareRecordResponse) String() string { return proto.CompactTextString(m) } func (*MsgTransferTokenizeShareRecordResponse) ProtoMessage() {} func (*MsgTransferTokenizeShareRecordResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_e504a27354d32365, []int{7} + return fileDescriptor_a63931950704005e, []int{7} } func (m *MsgTransferTokenizeShareRecordResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -394,7 +394,7 @@ func (m *MsgDisableTokenizeShares) Reset() { *m = MsgDisableTokenizeShar func (m *MsgDisableTokenizeShares) String() string { return proto.CompactTextString(m) } func (*MsgDisableTokenizeShares) ProtoMessage() {} func (*MsgDisableTokenizeShares) Descriptor() ([]byte, []int) { - return fileDescriptor_e504a27354d32365, []int{8} + return fileDescriptor_a63931950704005e, []int{8} } func (m *MsgDisableTokenizeShares) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -432,7 +432,7 @@ func (m *MsgDisableTokenizeSharesResponse) Reset() { *m = MsgDisableToke func (m *MsgDisableTokenizeSharesResponse) String() string { return proto.CompactTextString(m) } func (*MsgDisableTokenizeSharesResponse) ProtoMessage() {} func (*MsgDisableTokenizeSharesResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_e504a27354d32365, []int{9} + return fileDescriptor_a63931950704005e, []int{9} } func (m *MsgDisableTokenizeSharesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -470,7 +470,7 @@ func (m *MsgEnableTokenizeShares) Reset() { *m = MsgEnableTokenizeShares func (m *MsgEnableTokenizeShares) String() string { return proto.CompactTextString(m) } func (*MsgEnableTokenizeShares) ProtoMessage() {} func (*MsgEnableTokenizeShares) Descriptor() ([]byte, []int) { - return fileDescriptor_e504a27354d32365, []int{10} + return fileDescriptor_a63931950704005e, []int{10} } func (m *MsgEnableTokenizeShares) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -509,7 +509,7 @@ func (m *MsgEnableTokenizeSharesResponse) Reset() { *m = MsgEnableTokeni func (m *MsgEnableTokenizeSharesResponse) String() string { return proto.CompactTextString(m) } func (*MsgEnableTokenizeSharesResponse) ProtoMessage() {} func (*MsgEnableTokenizeSharesResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_e504a27354d32365, []int{11} + return fileDescriptor_a63931950704005e, []int{11} } func (m *MsgEnableTokenizeSharesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -556,7 +556,7 @@ func (m *MsgWithdrawTokenizeShareRecordReward) Reset() { *m = MsgWithdra func (m *MsgWithdrawTokenizeShareRecordReward) String() string { return proto.CompactTextString(m) } func (*MsgWithdrawTokenizeShareRecordReward) ProtoMessage() {} func (*MsgWithdrawTokenizeShareRecordReward) Descriptor() ([]byte, []int) { - return fileDescriptor_e504a27354d32365, []int{12} + return fileDescriptor_a63931950704005e, []int{12} } func (m *MsgWithdrawTokenizeShareRecordReward) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -598,7 +598,7 @@ func (m *MsgWithdrawTokenizeShareRecordRewardResponse) String() string { } func (*MsgWithdrawTokenizeShareRecordRewardResponse) ProtoMessage() {} func (*MsgWithdrawTokenizeShareRecordRewardResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_e504a27354d32365, []int{13} + return fileDescriptor_a63931950704005e, []int{13} } func (m *MsgWithdrawTokenizeShareRecordRewardResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -639,7 +639,7 @@ func (m *MsgWithdrawAllTokenizeShareRecordReward) Reset() { func (m *MsgWithdrawAllTokenizeShareRecordReward) String() string { return proto.CompactTextString(m) } func (*MsgWithdrawAllTokenizeShareRecordReward) ProtoMessage() {} func (*MsgWithdrawAllTokenizeShareRecordReward) Descriptor() ([]byte, []int) { - return fileDescriptor_e504a27354d32365, []int{14} + return fileDescriptor_a63931950704005e, []int{14} } func (m *MsgWithdrawAllTokenizeShareRecordReward) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -681,7 +681,7 @@ func (m *MsgWithdrawAllTokenizeShareRecordRewardResponse) String() string { } func (*MsgWithdrawAllTokenizeShareRecordRewardResponse) ProtoMessage() {} func (*MsgWithdrawAllTokenizeShareRecordRewardResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_e504a27354d32365, []int{15} + return fileDescriptor_a63931950704005e, []int{15} } func (m *MsgWithdrawAllTokenizeShareRecordRewardResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -711,93 +711,94 @@ func (m *MsgWithdrawAllTokenizeShareRecordRewardResponse) XXX_DiscardUnknown() { var xxx_messageInfo_MsgWithdrawAllTokenizeShareRecordRewardResponse proto.InternalMessageInfo func init() { - proto.RegisterType((*MsgUpdateParams)(nil), "gaia.liquid.v1beta1.MsgUpdateParams") - proto.RegisterType((*MsgUpdateParamsResponse)(nil), "gaia.liquid.v1beta1.MsgUpdateParamsResponse") - proto.RegisterType((*MsgTokenizeShares)(nil), "gaia.liquid.v1beta1.MsgTokenizeShares") - proto.RegisterType((*MsgTokenizeSharesResponse)(nil), "gaia.liquid.v1beta1.MsgTokenizeSharesResponse") - proto.RegisterType((*MsgRedeemTokensForShares)(nil), "gaia.liquid.v1beta1.MsgRedeemTokensForShares") - proto.RegisterType((*MsgRedeemTokensForSharesResponse)(nil), "gaia.liquid.v1beta1.MsgRedeemTokensForSharesResponse") - proto.RegisterType((*MsgTransferTokenizeShareRecord)(nil), "gaia.liquid.v1beta1.MsgTransferTokenizeShareRecord") - proto.RegisterType((*MsgTransferTokenizeShareRecordResponse)(nil), "gaia.liquid.v1beta1.MsgTransferTokenizeShareRecordResponse") - proto.RegisterType((*MsgDisableTokenizeShares)(nil), "gaia.liquid.v1beta1.MsgDisableTokenizeShares") - proto.RegisterType((*MsgDisableTokenizeSharesResponse)(nil), "gaia.liquid.v1beta1.MsgDisableTokenizeSharesResponse") - proto.RegisterType((*MsgEnableTokenizeShares)(nil), "gaia.liquid.v1beta1.MsgEnableTokenizeShares") - proto.RegisterType((*MsgEnableTokenizeSharesResponse)(nil), "gaia.liquid.v1beta1.MsgEnableTokenizeSharesResponse") - proto.RegisterType((*MsgWithdrawTokenizeShareRecordReward)(nil), "gaia.liquid.v1beta1.MsgWithdrawTokenizeShareRecordReward") - proto.RegisterType((*MsgWithdrawTokenizeShareRecordRewardResponse)(nil), "gaia.liquid.v1beta1.MsgWithdrawTokenizeShareRecordRewardResponse") - proto.RegisterType((*MsgWithdrawAllTokenizeShareRecordReward)(nil), "gaia.liquid.v1beta1.MsgWithdrawAllTokenizeShareRecordReward") - proto.RegisterType((*MsgWithdrawAllTokenizeShareRecordRewardResponse)(nil), "gaia.liquid.v1beta1.MsgWithdrawAllTokenizeShareRecordRewardResponse") -} - -func init() { proto.RegisterFile("gaia/liquid/v1beta1/tx.proto", fileDescriptor_e504a27354d32365) } - -var fileDescriptor_e504a27354d32365 = []byte{ - // 1030 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x57, 0x4d, 0x6f, 0xdc, 0x44, - 0x18, 0xde, 0xd9, 0x84, 0x28, 0x3b, 0x94, 0xb6, 0x71, 0xd3, 0xd6, 0xf1, 0x86, 0xdd, 0x60, 0x42, - 0x09, 0x51, 0x6a, 0x6b, 0x53, 0xa0, 0xea, 0x16, 0x28, 0x59, 0x0a, 0xa2, 0x42, 0x2b, 0x90, 0x1b, - 0x84, 0x04, 0x87, 0xd5, 0xec, 0x7a, 0xea, 0xb5, 0xb0, 0x3d, 0x8b, 0xc7, 0x9b, 0x6d, 0x2a, 0x21, - 0x21, 0x4e, 0x88, 0x0b, 0xfd, 0x09, 0xe5, 0x80, 0x40, 0x9c, 0x72, 0x00, 0x21, 0xfe, 0x41, 0x25, - 0x38, 0x14, 0x4e, 0x9c, 0x42, 0x95, 0x1c, 0xc2, 0xb9, 0xbf, 0x00, 0xcd, 0x78, 0xec, 0xfd, 0xb2, - 0xf7, 0xa3, 0x6d, 0x2e, 0xc9, 0x7a, 0xde, 0xe7, 0x7d, 0xe7, 0x7d, 0x9e, 0x79, 0x66, 0xc6, 0x86, - 0xcb, 0x16, 0xb2, 0x91, 0xee, 0xd8, 0x5f, 0xb4, 0x6d, 0x53, 0xdf, 0x29, 0xd5, 0x71, 0x80, 0x4a, - 0x7a, 0x70, 0x5b, 0x6b, 0xf9, 0x24, 0x20, 0xd2, 0x19, 0x16, 0xd5, 0xc2, 0xa8, 0x26, 0xa2, 0x4a, - 0xd1, 0x22, 0xc4, 0x72, 0xb0, 0xce, 0x21, 0xf5, 0xf6, 0x2d, 0x3d, 0xb0, 0x5d, 0x4c, 0x03, 0xe4, - 0xb6, 0xc2, 0x2c, 0x65, 0xd1, 0x22, 0x16, 0xe1, 0x3f, 0x75, 0xf6, 0x4b, 0x8c, 0x2e, 0x35, 0x08, - 0x75, 0x09, 0xad, 0x85, 0x81, 0xf0, 0x41, 0x84, 0x0a, 0xe1, 0x93, 0x5e, 0x47, 0x14, 0xc7, 0x4d, - 0x34, 0x88, 0xed, 0x89, 0xf8, 0x4a, 0x52, 0x93, 0xa2, 0xab, 0x10, 0x71, 0x5e, 0x54, 0x70, 0xa9, - 0xa5, 0xef, 0x94, 0xd8, 0x3f, 0x11, 0x58, 0x40, 0xae, 0xed, 0x11, 0x9d, 0xff, 0x0d, 0x87, 0xd4, - 0xdf, 0x01, 0x3c, 0x55, 0xa5, 0xd6, 0xc7, 0x2d, 0x13, 0x05, 0xf8, 0x23, 0xe4, 0x23, 0x97, 0x4a, - 0xaf, 0xc3, 0x1c, 0x6a, 0x07, 0x4d, 0xe2, 0xdb, 0xc1, 0xae, 0x0c, 0x56, 0xc0, 0x5a, 0xae, 0x22, - 0xff, 0xfd, 0xcb, 0xc5, 0x45, 0xd1, 0xe6, 0x96, 0x69, 0xfa, 0x98, 0xd2, 0x9b, 0x81, 0x6f, 0x7b, - 0x96, 0xd1, 0x85, 0x4a, 0x6f, 0xc1, 0xb9, 0x16, 0xaf, 0x20, 0x67, 0x57, 0xc0, 0xda, 0xb3, 0x9b, - 0x79, 0x2d, 0x41, 0x31, 0x2d, 0x9c, 0xa4, 0x92, 0xbb, 0xbf, 0x5f, 0xcc, 0xfc, 0x74, 0xb4, 0xb7, - 0x0e, 0x0c, 0x91, 0x55, 0xd6, 0xbe, 0x3e, 0xda, 0x5b, 0xef, 0xd6, 0xfb, 0xf6, 0x68, 0x6f, 0x3d, - 0xdf, 0x4b, 0x76, 0xa0, 0x4f, 0x75, 0x09, 0x9e, 0x1f, 0x18, 0x32, 0x30, 0x6d, 0x11, 0x8f, 0x62, - 0xf5, 0xaf, 0x2c, 0x5c, 0xa8, 0x52, 0x6b, 0x9b, 0x7c, 0x8e, 0x3d, 0xfb, 0x0e, 0xbe, 0xd9, 0x44, - 0x3e, 0xa6, 0xd2, 0x0d, 0xb8, 0x60, 0x62, 0x07, 0x5b, 0x28, 0x20, 0x7e, 0x0d, 0x85, 0x34, 0x04, - 0xc1, 0xe5, 0x47, 0xfb, 0x45, 0x79, 0x17, 0xb9, 0x4e, 0x59, 0x1d, 0x82, 0xa8, 0xc6, 0xe9, 0x78, - 0x4c, 0x90, 0x67, 0xa5, 0x76, 0x90, 0x63, 0x9b, 0x7d, 0xa5, 0xb2, 0x83, 0xa5, 0x86, 0x20, 0xaa, - 0x71, 0x3a, 0x1e, 0x8b, 0x4a, 0x5d, 0x86, 0x73, 0xc8, 0x25, 0x6d, 0x2f, 0x90, 0x67, 0xb8, 0x6c, - 0x4b, 0x9a, 0x10, 0x9a, 0x39, 0x20, 0x96, 0xed, 0x1d, 0x62, 0x7b, 0x95, 0x59, 0x26, 0x9a, 0x21, - 0xe0, 0xd2, 0x26, 0x3c, 0x1b, 0x08, 0x82, 0x66, 0x8d, 0x32, 0x8a, 0x35, 0xd2, 0xf1, 0xb0, 0x2f, - 0xcf, 0xb2, 0x3e, 0x8c, 0x33, 0x71, 0x90, 0xd3, 0xff, 0x90, 0x85, 0xca, 0x57, 0xbe, 0xb9, 0x57, - 0xcc, 0xfc, 0x77, 0xaf, 0x98, 0x61, 0x5a, 0x0f, 0xab, 0xc1, 0x34, 0x3f, 0xc7, 0x35, 0x1f, 0x52, - 0x4f, 0xdd, 0x86, 0x4b, 0x43, 0x83, 0x91, 0xe0, 0x3d, 0x24, 0xc0, 0x54, 0x24, 0xd4, 0x87, 0x00, - 0xca, 0x55, 0x6a, 0x19, 0xd8, 0xc4, 0xd8, 0xe5, 0xc5, 0xe9, 0x7b, 0xc4, 0x7f, 0xfa, 0x0b, 0xd6, - 0x6d, 0x30, 0x3b, 0x55, 0x83, 0xe5, 0xb7, 0xc7, 0x2b, 0xf6, 0x7c, 0xa4, 0x58, 0x22, 0x0b, 0xf5, - 0x33, 0xb8, 0x92, 0x16, 0x7b, 0x72, 0xfd, 0xfe, 0x00, 0xb0, 0xc0, 0x96, 0xc5, 0x47, 0x1e, 0xbd, - 0x85, 0xfd, 0xbe, 0xe5, 0x31, 0x70, 0x83, 0xf8, 0xa6, 0x74, 0x19, 0xca, 0x91, 0x15, 0x84, 0x4d, - 0x7c, 0x1e, 0xa8, 0xd9, 0x26, 0x9f, 0x6d, 0xd6, 0x88, 0x7d, 0xd4, 0x93, 0x76, 0xc3, 0x94, 0xce, - 0xc1, 0x39, 0x8a, 0x3d, 0x13, 0xfb, 0xa1, 0xb3, 0x0d, 0xf1, 0x24, 0xe5, 0x61, 0xce, 0xc3, 0x1d, - 0x61, 0xb6, 0x19, 0x1e, 0x9a, 0xf7, 0x70, 0x27, 0x74, 0xd8, 0xd5, 0x5e, 0xbd, 0x44, 0x06, 0x13, - 0xe9, 0xc5, 0xd8, 0x56, 0xe9, 0xad, 0xaa, 0x6b, 0xf0, 0xc2, 0x68, 0x44, 0xbc, 0xc3, 0x7f, 0x0c, - 0x7d, 0x73, 0xdd, 0xa6, 0xa8, 0xee, 0xe0, 0x63, 0xdb, 0xe8, 0x53, 0x2d, 0x7f, 0x62, 0x33, 0xaa, - 0xca, 0x97, 0x3f, 0x31, 0x16, 0xb3, 0xf9, 0x01, 0xf0, 0xb3, 0xec, 0x5d, 0xef, 0x78, 0xc9, 0x5c, - 0x1b, 0x4f, 0x66, 0x39, 0x22, 0x93, 0xd4, 0x8b, 0xda, 0x82, 0xc5, 0x94, 0x50, 0xec, 0xe4, 0x2a, - 0x3c, 0xd5, 0x20, 0x6e, 0xcb, 0xc1, 0x81, 0x4d, 0xbc, 0x1a, 0xbb, 0x0e, 0x85, 0xa5, 0x15, 0x2d, - 0xbc, 0x2b, 0xb5, 0xe8, 0xae, 0xd4, 0xb6, 0xa3, 0xbb, 0xb2, 0x32, 0xcf, 0x3c, 0x7d, 0xf7, 0xdf, - 0x22, 0x30, 0x4e, 0x76, 0x93, 0x59, 0x58, 0xfd, 0x13, 0xc0, 0xd5, 0x2a, 0xb5, 0x3e, 0xb1, 0x83, - 0xa6, 0xe9, 0xa3, 0x4e, 0xa2, 0x25, 0x3a, 0xc8, 0x37, 0xa5, 0x37, 0xe1, 0x73, 0xdc, 0x90, 0x03, - 0x12, 0xc9, 0x8f, 0xf6, 0x8b, 0x8b, 0xa1, 0x44, 0x7d, 0x61, 0xd5, 0x38, 0xc1, 0x9f, 0xa3, 0xf3, - 0x21, 0x0f, 0x73, 0xdd, 0x5d, 0x91, 0xe5, 0xbb, 0x62, 0xde, 0x17, 0x1b, 0xa1, 0xfc, 0x7e, 0xaf, - 0x6e, 0xfd, 0xd3, 0x30, 0xcd, 0x5e, 0x89, 0x34, 0x1b, 0xdb, 0xa5, 0xaa, 0xc1, 0x8d, 0x49, 0x70, - 0xb1, 0x31, 0x7e, 0x05, 0xf0, 0xe5, 0x9e, 0x84, 0x2d, 0xc7, 0x39, 0x2e, 0x05, 0xca, 0x1f, 0x8c, - 0x26, 0xb9, 0x31, 0x48, 0x72, 0x54, 0x2f, 0x6a, 0x09, 0x4e, 0x0a, 0x8d, 0xa8, 0x6e, 0xfe, 0x36, - 0x0f, 0x67, 0xaa, 0xd4, 0x92, 0xea, 0xf0, 0x44, 0xdf, 0xeb, 0xc8, 0x6a, 0xe2, 0x6b, 0xc4, 0xc0, - 0xcd, 0xaf, 0x6c, 0x4c, 0x82, 0x8a, 0x4d, 0xda, 0x84, 0x27, 0x07, 0x76, 0xd9, 0x85, 0xb4, 0xfc, - 0x7e, 0x9c, 0xa2, 0x4d, 0x86, 0x8b, 0x67, 0xfa, 0x12, 0x9e, 0x4d, 0xbe, 0xdb, 0x2e, 0xa6, 0x15, - 0x4a, 0x84, 0x2b, 0xaf, 0x4d, 0x05, 0x8f, 0xa7, 0xff, 0x0e, 0xc0, 0xfc, 0xa8, 0xbb, 0xe1, 0x52, - 0x2a, 0x9d, 0xf4, 0x24, 0xe5, 0xea, 0x63, 0x24, 0xf5, 0x0a, 0x92, 0x7c, 0x68, 0xa7, 0x0a, 0x92, - 0x08, 0x4f, 0x17, 0x64, 0xe4, 0x49, 0x2b, 0xdd, 0x81, 0x8b, 0x89, 0xa7, 0x6c, 0xaa, 0x7f, 0x92, - 0xd0, 0xca, 0xab, 0xd3, 0xa0, 0xe3, 0xb9, 0xbf, 0x07, 0xf0, 0x85, 0xf1, 0x07, 0xd9, 0x95, 0xb4, - 0xda, 0x63, 0x53, 0x95, 0xad, 0xc7, 0x4e, 0x8d, 0x7b, 0xfc, 0x19, 0xc0, 0xd5, 0x89, 0x4e, 0x9b, - 0x37, 0xc6, 0xcd, 0x35, 0x2a, 0x5b, 0xb9, 0xfe, 0x24, 0xd9, 0x51, 0xb3, 0xca, 0x33, 0x5f, 0xb1, - 0x0f, 0x88, 0xca, 0xb5, 0xfb, 0x07, 0x05, 0xf0, 0xe0, 0xa0, 0x00, 0x1e, 0x1e, 0x14, 0xc0, 0xdd, - 0xc3, 0x42, 0xe6, 0xc1, 0x61, 0x21, 0xf3, 0xcf, 0x61, 0x21, 0xf3, 0xe9, 0x4b, 0x96, 0x1d, 0x34, - 0xdb, 0x75, 0xad, 0x41, 0x5c, 0xf1, 0x95, 0xa5, 0xf3, 0x63, 0xec, 0x76, 0xf4, 0x4d, 0x11, 0xec, - 0xb6, 0x30, 0xad, 0xcf, 0xf1, 0x2b, 0xe9, 0xd2, 0xff, 0x01, 0x00, 0x00, 0xff, 0xff, 0xcc, 0x28, - 0x23, 0xcc, 0x01, 0x0e, 0x00, 0x00, + proto.RegisterType((*MsgUpdateParams)(nil), "kyve.liquid.v1beta1.MsgUpdateParams") + proto.RegisterType((*MsgUpdateParamsResponse)(nil), "kyve.liquid.v1beta1.MsgUpdateParamsResponse") + proto.RegisterType((*MsgTokenizeShares)(nil), "kyve.liquid.v1beta1.MsgTokenizeShares") + proto.RegisterType((*MsgTokenizeSharesResponse)(nil), "kyve.liquid.v1beta1.MsgTokenizeSharesResponse") + proto.RegisterType((*MsgRedeemTokensForShares)(nil), "kyve.liquid.v1beta1.MsgRedeemTokensForShares") + proto.RegisterType((*MsgRedeemTokensForSharesResponse)(nil), "kyve.liquid.v1beta1.MsgRedeemTokensForSharesResponse") + proto.RegisterType((*MsgTransferTokenizeShareRecord)(nil), "kyve.liquid.v1beta1.MsgTransferTokenizeShareRecord") + proto.RegisterType((*MsgTransferTokenizeShareRecordResponse)(nil), "kyve.liquid.v1beta1.MsgTransferTokenizeShareRecordResponse") + proto.RegisterType((*MsgDisableTokenizeShares)(nil), "kyve.liquid.v1beta1.MsgDisableTokenizeShares") + proto.RegisterType((*MsgDisableTokenizeSharesResponse)(nil), "kyve.liquid.v1beta1.MsgDisableTokenizeSharesResponse") + proto.RegisterType((*MsgEnableTokenizeShares)(nil), "kyve.liquid.v1beta1.MsgEnableTokenizeShares") + proto.RegisterType((*MsgEnableTokenizeSharesResponse)(nil), "kyve.liquid.v1beta1.MsgEnableTokenizeSharesResponse") + proto.RegisterType((*MsgWithdrawTokenizeShareRecordReward)(nil), "kyve.liquid.v1beta1.MsgWithdrawTokenizeShareRecordReward") + proto.RegisterType((*MsgWithdrawTokenizeShareRecordRewardResponse)(nil), "kyve.liquid.v1beta1.MsgWithdrawTokenizeShareRecordRewardResponse") + proto.RegisterType((*MsgWithdrawAllTokenizeShareRecordReward)(nil), "kyve.liquid.v1beta1.MsgWithdrawAllTokenizeShareRecordReward") + proto.RegisterType((*MsgWithdrawAllTokenizeShareRecordRewardResponse)(nil), "kyve.liquid.v1beta1.MsgWithdrawAllTokenizeShareRecordRewardResponse") +} + +func init() { proto.RegisterFile("kyve/liquid/v1beta1/tx.proto", fileDescriptor_a63931950704005e) } + +var fileDescriptor_a63931950704005e = []byte{ + // 1043 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x57, 0x4d, 0x6f, 0x1b, 0x45, + 0x18, 0xf6, 0x24, 0x21, 0x8a, 0x87, 0xd2, 0x36, 0xdb, 0xb4, 0x75, 0xd6, 0xc1, 0x0e, 0x4b, 0x54, + 0x42, 0x48, 0x77, 0x95, 0x14, 0xa8, 0xea, 0xf2, 0x15, 0xd3, 0x20, 0xaa, 0xca, 0x80, 0xb6, 0x01, + 0x04, 0x1c, 0xac, 0xb1, 0x77, 0xba, 0x5e, 0xc5, 0xbb, 0x63, 0x66, 0xd6, 0x71, 0x53, 0x09, 0x09, + 0x71, 0x42, 0x5c, 0xe8, 0x4f, 0x28, 0x07, 0x04, 0xe2, 0x94, 0x03, 0x08, 0xf1, 0x0f, 0x2a, 0xc1, + 0xa1, 0x70, 0xe2, 0x14, 0xaa, 0xe4, 0x10, 0xce, 0xfd, 0x05, 0x68, 0x66, 0x67, 0xd7, 0x5f, 0xbb, + 0xfe, 0x68, 0xc9, 0x25, 0xf1, 0xcc, 0xfb, 0xbc, 0xef, 0xbc, 0xcf, 0x33, 0xcf, 0xcc, 0xd8, 0x70, + 0x61, 0x7b, 0x77, 0x07, 0x1b, 0x75, 0xe7, 0xf3, 0xa6, 0x63, 0x19, 0x3b, 0x6b, 0x15, 0xec, 0xa3, + 0x35, 0xc3, 0xbf, 0xad, 0x37, 0x28, 0xf1, 0x89, 0x72, 0x86, 0x47, 0xf5, 0x20, 0xaa, 0xcb, 0xa8, + 0x3a, 0x8b, 0x5c, 0xc7, 0x23, 0x86, 0xf8, 0x1b, 0xe0, 0xd4, 0x5c, 0x95, 0x30, 0x97, 0x30, 0xa3, + 0x82, 0x18, 0x8e, 0xaa, 0x54, 0x89, 0xe3, 0xc9, 0xf8, 0x79, 0x19, 0x77, 0x99, 0x6d, 0xec, 0xac, + 0xf1, 0x7f, 0x32, 0x30, 0x1f, 0x04, 0xca, 0x62, 0x64, 0x04, 0x03, 0x19, 0x9a, 0xb3, 0x89, 0x4d, + 0x82, 0x79, 0xfe, 0x49, 0xce, 0xe6, 0x6d, 0x42, 0xec, 0x3a, 0x36, 0xc4, 0xa8, 0xd2, 0xbc, 0x65, + 0xf8, 0x8e, 0x8b, 0x99, 0x8f, 0xdc, 0x86, 0x04, 0x2c, 0xc6, 0x11, 0x92, 0x0c, 0x04, 0x42, 0xfb, + 0x0d, 0xc0, 0x53, 0x25, 0x66, 0x7f, 0xd8, 0xb0, 0x90, 0x8f, 0x3f, 0x40, 0x14, 0xb9, 0x4c, 0x79, + 0x15, 0xa6, 0x51, 0xd3, 0xaf, 0x11, 0xea, 0xf8, 0xbb, 0x19, 0xb0, 0x08, 0x96, 0xd3, 0xc5, 0xcc, + 0x5f, 0x3f, 0x5f, 0x9c, 0x93, 0x1d, 0x6d, 0x58, 0x16, 0xc5, 0x8c, 0xdd, 0xf4, 0xa9, 0xe3, 0xd9, + 0x66, 0x1b, 0xaa, 0xbc, 0x01, 0xa7, 0x1b, 0xa2, 0x42, 0x66, 0x62, 0x11, 0x2c, 0x3f, 0xbd, 0x9e, + 0xd5, 0x63, 0x14, 0xd3, 0x83, 0x45, 0x8a, 0xe9, 0xfb, 0xfb, 0xf9, 0xd4, 0x8f, 0x47, 0x7b, 0x2b, + 0xc0, 0x94, 0x59, 0x05, 0xfd, 0xab, 0xa3, 0xbd, 0x95, 0x76, 0xbd, 0x6f, 0x8e, 0xf6, 0x56, 0xb2, + 0x36, 0x72, 0x50, 0x48, 0xa0, 0xa7, 0x4f, 0x6d, 0x1e, 0x9e, 0xef, 0x99, 0x32, 0x31, 0x6b, 0x10, + 0x8f, 0x61, 0xed, 0xcf, 0x09, 0x38, 0x5b, 0x62, 0xf6, 0x16, 0xd9, 0xc6, 0x9e, 0x73, 0x07, 0xdf, + 0xac, 0x21, 0x8a, 0x99, 0x72, 0x1d, 0xce, 0x5a, 0xb8, 0x8e, 0x6d, 0xe4, 0x13, 0x5a, 0x46, 0x01, + 0x0d, 0x49, 0x70, 0xe1, 0xd1, 0x7e, 0x3e, 0xb3, 0x8b, 0xdc, 0x7a, 0x41, 0xeb, 0x83, 0x68, 0xe6, + 0xe9, 0x68, 0x4e, 0x92, 0xe7, 0xa5, 0x76, 0x50, 0xdd, 0xb1, 0xba, 0x4a, 0x4d, 0xf4, 0x96, 0xea, + 0x83, 0x68, 0xe6, 0xe9, 0x68, 0x2e, 0x2c, 0x75, 0x19, 0x4e, 0x23, 0x97, 0x34, 0x3d, 0x3f, 0x33, + 0x29, 0x64, 0x9b, 0xd7, 0xa5, 0xd0, 0xdc, 0x40, 0x91, 0x6c, 0x6f, 0x13, 0xc7, 0x2b, 0x4e, 0x71, + 0xd1, 0x4c, 0x09, 0x57, 0xd6, 0xe1, 0x59, 0x5f, 0x12, 0xb4, 0xca, 0x8c, 0x53, 0x2c, 0x93, 0x96, + 0x87, 0x69, 0x66, 0x8a, 0xf7, 0x61, 0x9e, 0x89, 0x82, 0x82, 0xfe, 0xfb, 0x3c, 0x54, 0xb8, 0xf2, + 0xf5, 0xbd, 0x7c, 0xea, 0xdf, 0x7b, 0xf9, 0x14, 0xd7, 0xba, 0x5f, 0x0d, 0xae, 0xf9, 0x39, 0xa1, + 0x79, 0x9f, 0x7a, 0xda, 0x16, 0x9c, 0xef, 0x9b, 0x0c, 0x05, 0xef, 0x20, 0x01, 0xc6, 0x22, 0xa1, + 0x3d, 0x04, 0x30, 0x53, 0x62, 0xb6, 0x89, 0x2d, 0x8c, 0x5d, 0x51, 0x9c, 0xbd, 0x43, 0xe8, 0xff, + 0xbf, 0x61, 0xed, 0x06, 0x27, 0xc6, 0x6a, 0xb0, 0xf0, 0xd6, 0x70, 0xc5, 0x9e, 0x0d, 0x15, 0x8b, + 0x65, 0xa1, 0x7d, 0x06, 0x17, 0x93, 0x62, 0x4f, 0xae, 0xdf, 0xef, 0x00, 0xe6, 0xf8, 0xb6, 0x50, + 0xe4, 0xb1, 0x5b, 0x98, 0x76, 0x6d, 0x8f, 0x89, 0xab, 0x84, 0x5a, 0xca, 0x65, 0x98, 0x09, 0xad, + 0x20, 0x6d, 0x42, 0x45, 0xa0, 0xec, 0x58, 0x62, 0xb5, 0x29, 0x33, 0xf2, 0x51, 0x47, 0xda, 0x75, + 0x4b, 0x39, 0x07, 0xa7, 0x19, 0xf6, 0x2c, 0x4c, 0x03, 0x67, 0x9b, 0x72, 0xa4, 0x64, 0x61, 0xda, + 0xc3, 0x2d, 0x69, 0xb6, 0x49, 0x11, 0x9a, 0xf1, 0x70, 0x2b, 0x70, 0xd8, 0xd5, 0x4e, 0xbd, 0x64, + 0x06, 0x17, 0xe9, 0xf9, 0xc8, 0x56, 0xc9, 0xad, 0x6a, 0xcb, 0xf0, 0xc2, 0x60, 0x44, 0x74, 0xc2, + 0x7f, 0x08, 0x7c, 0x73, 0xcd, 0x61, 0xa8, 0x52, 0xc7, 0xc7, 0x76, 0xd0, 0xc7, 0xda, 0xfe, 0xd8, + 0x66, 0x34, 0x4d, 0x6c, 0x7f, 0x6c, 0x2c, 0x62, 0xf3, 0x3d, 0x10, 0x77, 0xd9, 0xa6, 0x77, 0xbc, + 0x64, 0xde, 0x1c, 0x4e, 0x66, 0x21, 0x24, 0x13, 0xd7, 0x8b, 0xd6, 0x80, 0xf9, 0x84, 0x50, 0xe4, + 0xe4, 0x12, 0x3c, 0x55, 0x25, 0x6e, 0xa3, 0x8e, 0x7d, 0x87, 0x78, 0x65, 0xfe, 0x22, 0x49, 0x4b, + 0xab, 0x7a, 0xf0, 0x5c, 0xe9, 0xe1, 0x73, 0xa5, 0x6f, 0x85, 0xcf, 0x55, 0x71, 0x86, 0x7b, 0xfa, + 0xee, 0x3f, 0x79, 0x60, 0x9e, 0x6c, 0x27, 0xf3, 0xb0, 0xf6, 0x07, 0x80, 0x4b, 0x25, 0x66, 0x7f, + 0xec, 0xf8, 0x35, 0x8b, 0xa2, 0x56, 0xac, 0x25, 0x5a, 0x88, 0x5a, 0xca, 0xeb, 0xf0, 0x19, 0x61, + 0xc8, 0x1e, 0x89, 0x32, 0x8f, 0xf6, 0xf3, 0x73, 0x81, 0x44, 0x5d, 0x61, 0xcd, 0x3c, 0x21, 0xc6, + 0xe1, 0xfd, 0x90, 0x85, 0xe9, 0xf6, 0xa9, 0x98, 0x10, 0xa7, 0x62, 0x86, 0xca, 0x83, 0x50, 0x78, + 0xb7, 0x53, 0xb7, 0xee, 0x65, 0xb8, 0x66, 0x2f, 0x86, 0x9a, 0x0d, 0xed, 0x52, 0xd3, 0xe1, 0xea, + 0x28, 0xb8, 0xc8, 0x18, 0xbf, 0x00, 0xf8, 0x42, 0x47, 0xc2, 0x46, 0xbd, 0x7e, 0x5c, 0x0a, 0x14, + 0x6e, 0x0c, 0x26, 0xb9, 0xda, 0x4b, 0x72, 0x50, 0x2f, 0xda, 0x1a, 0x1c, 0x15, 0x1a, 0x52, 0x5d, + 0xff, 0x75, 0x06, 0x4e, 0x96, 0x98, 0xad, 0x54, 0xe0, 0x89, 0xae, 0xaf, 0x23, 0x4b, 0xb1, 0x5f, + 0x23, 0x7a, 0x5e, 0x7e, 0x75, 0x75, 0x14, 0x54, 0x64, 0xd2, 0x1a, 0x3c, 0xd9, 0x73, 0xca, 0x2e, + 0x24, 0xe5, 0x77, 0xe3, 0x54, 0x7d, 0x34, 0x5c, 0xb4, 0xd2, 0x17, 0xf0, 0x6c, 0xfc, 0xdb, 0x76, + 0x31, 0xa9, 0x50, 0x2c, 0x5c, 0x7d, 0x65, 0x2c, 0x78, 0xb4, 0xfc, 0xb7, 0x00, 0x66, 0x07, 0xbd, + 0x0d, 0x97, 0x12, 0xe9, 0x24, 0x27, 0xa9, 0x57, 0x1f, 0x23, 0xa9, 0x53, 0x90, 0xf8, 0x4b, 0x3b, + 0x51, 0x90, 0x58, 0x78, 0xb2, 0x20, 0x03, 0x6f, 0x5a, 0xe5, 0x0e, 0x9c, 0x8b, 0xbd, 0x65, 0x13, + 0xfd, 0x13, 0x87, 0x56, 0x5f, 0x1e, 0x07, 0x1d, 0xad, 0xfd, 0x1d, 0x80, 0xcf, 0x0d, 0xbf, 0xc8, + 0xae, 0x24, 0xd5, 0x1e, 0x9a, 0xaa, 0x6e, 0x3c, 0x76, 0x6a, 0xd4, 0xe3, 0x4f, 0x00, 0x2e, 0x8d, + 0x74, 0xdb, 0xbc, 0x36, 0x6c, 0xad, 0x41, 0xd9, 0xea, 0xb5, 0x27, 0xc9, 0x0e, 0x9b, 0x55, 0x9f, + 0xfa, 0x92, 0xff, 0x80, 0x28, 0x6e, 0xde, 0x3f, 0xc8, 0x81, 0x07, 0x07, 0x39, 0xf0, 0xf0, 0x20, + 0x07, 0xee, 0x1e, 0xe6, 0x52, 0x0f, 0x0e, 0x73, 0xa9, 0xbf, 0x0f, 0x73, 0xa9, 0x4f, 0x5f, 0xb2, + 0x1d, 0xbf, 0xd6, 0xac, 0xe8, 0x55, 0xe2, 0x1a, 0x37, 0x3e, 0xf9, 0x68, 0xf3, 0x3d, 0xec, 0xb7, + 0x08, 0xdd, 0x36, 0xaa, 0x35, 0xe4, 0x78, 0xc6, 0xed, 0xf0, 0x97, 0x85, 0xbf, 0xdb, 0xc0, 0xac, + 0x32, 0x2d, 0x1e, 0xa6, 0x4b, 0xff, 0x05, 0x00, 0x00, 0xff, 0xff, 0x18, 0xac, 0xf5, 0x07, 0x07, + 0x0e, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -847,7 +848,7 @@ func NewMsgClient(cc grpc1.ClientConn) MsgClient { func (c *msgClient) UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error) { out := new(MsgUpdateParamsResponse) - err := c.cc.Invoke(ctx, "/gaia.liquid.v1beta1.Msg/UpdateParams", in, out, opts...) + err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Msg/UpdateParams", in, out, opts...) if err != nil { return nil, err } @@ -856,7 +857,7 @@ func (c *msgClient) UpdateParams(ctx context.Context, in *MsgUpdateParams, opts func (c *msgClient) TokenizeShares(ctx context.Context, in *MsgTokenizeShares, opts ...grpc.CallOption) (*MsgTokenizeSharesResponse, error) { out := new(MsgTokenizeSharesResponse) - err := c.cc.Invoke(ctx, "/gaia.liquid.v1beta1.Msg/TokenizeShares", in, out, opts...) + err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Msg/TokenizeShares", in, out, opts...) if err != nil { return nil, err } @@ -865,7 +866,7 @@ func (c *msgClient) TokenizeShares(ctx context.Context, in *MsgTokenizeShares, o func (c *msgClient) RedeemTokensForShares(ctx context.Context, in *MsgRedeemTokensForShares, opts ...grpc.CallOption) (*MsgRedeemTokensForSharesResponse, error) { out := new(MsgRedeemTokensForSharesResponse) - err := c.cc.Invoke(ctx, "/gaia.liquid.v1beta1.Msg/RedeemTokensForShares", in, out, opts...) + err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Msg/RedeemTokensForShares", in, out, opts...) if err != nil { return nil, err } @@ -874,7 +875,7 @@ func (c *msgClient) RedeemTokensForShares(ctx context.Context, in *MsgRedeemToke func (c *msgClient) TransferTokenizeShareRecord(ctx context.Context, in *MsgTransferTokenizeShareRecord, opts ...grpc.CallOption) (*MsgTransferTokenizeShareRecordResponse, error) { out := new(MsgTransferTokenizeShareRecordResponse) - err := c.cc.Invoke(ctx, "/gaia.liquid.v1beta1.Msg/TransferTokenizeShareRecord", in, out, opts...) + err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Msg/TransferTokenizeShareRecord", in, out, opts...) if err != nil { return nil, err } @@ -883,7 +884,7 @@ func (c *msgClient) TransferTokenizeShareRecord(ctx context.Context, in *MsgTran func (c *msgClient) DisableTokenizeShares(ctx context.Context, in *MsgDisableTokenizeShares, opts ...grpc.CallOption) (*MsgDisableTokenizeSharesResponse, error) { out := new(MsgDisableTokenizeSharesResponse) - err := c.cc.Invoke(ctx, "/gaia.liquid.v1beta1.Msg/DisableTokenizeShares", in, out, opts...) + err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Msg/DisableTokenizeShares", in, out, opts...) if err != nil { return nil, err } @@ -892,7 +893,7 @@ func (c *msgClient) DisableTokenizeShares(ctx context.Context, in *MsgDisableTok func (c *msgClient) EnableTokenizeShares(ctx context.Context, in *MsgEnableTokenizeShares, opts ...grpc.CallOption) (*MsgEnableTokenizeSharesResponse, error) { out := new(MsgEnableTokenizeSharesResponse) - err := c.cc.Invoke(ctx, "/gaia.liquid.v1beta1.Msg/EnableTokenizeShares", in, out, opts...) + err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Msg/EnableTokenizeShares", in, out, opts...) if err != nil { return nil, err } @@ -901,7 +902,7 @@ func (c *msgClient) EnableTokenizeShares(ctx context.Context, in *MsgEnableToken func (c *msgClient) WithdrawTokenizeShareRecordReward(ctx context.Context, in *MsgWithdrawTokenizeShareRecordReward, opts ...grpc.CallOption) (*MsgWithdrawTokenizeShareRecordRewardResponse, error) { out := new(MsgWithdrawTokenizeShareRecordRewardResponse) - err := c.cc.Invoke(ctx, "/gaia.liquid.v1beta1.Msg/WithdrawTokenizeShareRecordReward", in, out, opts...) + err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Msg/WithdrawTokenizeShareRecordReward", in, out, opts...) if err != nil { return nil, err } @@ -910,7 +911,7 @@ func (c *msgClient) WithdrawTokenizeShareRecordReward(ctx context.Context, in *M func (c *msgClient) WithdrawAllTokenizeShareRecordReward(ctx context.Context, in *MsgWithdrawAllTokenizeShareRecordReward, opts ...grpc.CallOption) (*MsgWithdrawAllTokenizeShareRecordRewardResponse, error) { out := new(MsgWithdrawAllTokenizeShareRecordRewardResponse) - err := c.cc.Invoke(ctx, "/gaia.liquid.v1beta1.Msg/WithdrawAllTokenizeShareRecordReward", in, out, opts...) + err := c.cc.Invoke(ctx, "/kyve.liquid.v1beta1.Msg/WithdrawAllTokenizeShareRecordReward", in, out, opts...) if err != nil { return nil, err } @@ -987,7 +988,7 @@ func _Msg_UpdateParams_Handler(srv interface{}, ctx context.Context, dec func(in } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/gaia.liquid.v1beta1.Msg/UpdateParams", + FullMethod: "/kyve.liquid.v1beta1.Msg/UpdateParams", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(MsgServer).UpdateParams(ctx, req.(*MsgUpdateParams)) @@ -1005,7 +1006,7 @@ func _Msg_TokenizeShares_Handler(srv interface{}, ctx context.Context, dec func( } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/gaia.liquid.v1beta1.Msg/TokenizeShares", + FullMethod: "/kyve.liquid.v1beta1.Msg/TokenizeShares", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(MsgServer).TokenizeShares(ctx, req.(*MsgTokenizeShares)) @@ -1023,7 +1024,7 @@ func _Msg_RedeemTokensForShares_Handler(srv interface{}, ctx context.Context, de } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/gaia.liquid.v1beta1.Msg/RedeemTokensForShares", + FullMethod: "/kyve.liquid.v1beta1.Msg/RedeemTokensForShares", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(MsgServer).RedeemTokensForShares(ctx, req.(*MsgRedeemTokensForShares)) @@ -1041,7 +1042,7 @@ func _Msg_TransferTokenizeShareRecord_Handler(srv interface{}, ctx context.Conte } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/gaia.liquid.v1beta1.Msg/TransferTokenizeShareRecord", + FullMethod: "/kyve.liquid.v1beta1.Msg/TransferTokenizeShareRecord", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(MsgServer).TransferTokenizeShareRecord(ctx, req.(*MsgTransferTokenizeShareRecord)) @@ -1059,7 +1060,7 @@ func _Msg_DisableTokenizeShares_Handler(srv interface{}, ctx context.Context, de } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/gaia.liquid.v1beta1.Msg/DisableTokenizeShares", + FullMethod: "/kyve.liquid.v1beta1.Msg/DisableTokenizeShares", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(MsgServer).DisableTokenizeShares(ctx, req.(*MsgDisableTokenizeShares)) @@ -1077,7 +1078,7 @@ func _Msg_EnableTokenizeShares_Handler(srv interface{}, ctx context.Context, dec } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/gaia.liquid.v1beta1.Msg/EnableTokenizeShares", + FullMethod: "/kyve.liquid.v1beta1.Msg/EnableTokenizeShares", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(MsgServer).EnableTokenizeShares(ctx, req.(*MsgEnableTokenizeShares)) @@ -1095,7 +1096,7 @@ func _Msg_WithdrawTokenizeShareRecordReward_Handler(srv interface{}, ctx context } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/gaia.liquid.v1beta1.Msg/WithdrawTokenizeShareRecordReward", + FullMethod: "/kyve.liquid.v1beta1.Msg/WithdrawTokenizeShareRecordReward", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(MsgServer).WithdrawTokenizeShareRecordReward(ctx, req.(*MsgWithdrawTokenizeShareRecordReward)) @@ -1113,7 +1114,7 @@ func _Msg_WithdrawAllTokenizeShareRecordReward_Handler(srv interface{}, ctx cont } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/gaia.liquid.v1beta1.Msg/WithdrawAllTokenizeShareRecordReward", + FullMethod: "/kyve.liquid.v1beta1.Msg/WithdrawAllTokenizeShareRecordReward", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(MsgServer).WithdrawAllTokenizeShareRecordReward(ctx, req.(*MsgWithdrawAllTokenizeShareRecordReward)) @@ -1123,7 +1124,7 @@ func _Msg_WithdrawAllTokenizeShareRecordReward_Handler(srv interface{}, ctx cont var Msg_serviceDesc = _Msg_serviceDesc var _Msg_serviceDesc = grpc.ServiceDesc{ - ServiceName: "gaia.liquid.v1beta1.Msg", + ServiceName: "kyve.liquid.v1beta1.Msg", HandlerType: (*MsgServer)(nil), Methods: []grpc.MethodDesc{ { @@ -1160,7 +1161,7 @@ var _Msg_serviceDesc = grpc.ServiceDesc{ }, }, Streams: []grpc.StreamDesc{}, - Metadata: "gaia/liquid/v1beta1/tx.proto", + Metadata: "kyve/liquid/v1beta1/tx.proto", } func (m *MsgUpdateParams) Marshal() (dAtA []byte, err error) { From 2db71a63dd063e628c4c99f874133b9008e6a750 Mon Sep 17 00:00:00 2001 From: mbreithecker Date: Wed, 30 Jul 2025 14:07:04 +0200 Subject: [PATCH 4/8] chore: wire up liquid module --- api/kyve/liquid/module/v1/module.pulsar.go | 735 +++++++++++++++++++++ app/app.go | 7 + app/app_config.go | 13 + 3 files changed, 755 insertions(+) create mode 100644 api/kyve/liquid/module/v1/module.pulsar.go diff --git a/api/kyve/liquid/module/v1/module.pulsar.go b/api/kyve/liquid/module/v1/module.pulsar.go new file mode 100644 index 00000000..c4d476df --- /dev/null +++ b/api/kyve/liquid/module/v1/module.pulsar.go @@ -0,0 +1,735 @@ +// Code generated by protoc-gen-go-pulsar. DO NOT EDIT. +package modulev1 + +import ( + _ "cosmossdk.io/api/cosmos/app/v1alpha1" + fmt "fmt" + runtime "github.com/cosmos/cosmos-proto/runtime" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoiface "google.golang.org/protobuf/runtime/protoiface" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + io "io" + reflect "reflect" + sync "sync" +) + +var ( + md_Module protoreflect.MessageDescriptor + fd_Module_authority protoreflect.FieldDescriptor + fd_Module_bech32_prefix_validator protoreflect.FieldDescriptor + fd_Module_bech32_prefix_consensus protoreflect.FieldDescriptor +) + +func init() { + file_kyve_liquid_module_v1_module_proto_init() + md_Module = File_kyve_liquid_module_v1_module_proto.Messages().ByName("Module") + fd_Module_authority = md_Module.Fields().ByName("authority") + fd_Module_bech32_prefix_validator = md_Module.Fields().ByName("bech32_prefix_validator") + fd_Module_bech32_prefix_consensus = md_Module.Fields().ByName("bech32_prefix_consensus") +} + +var _ protoreflect.Message = (*fastReflection_Module)(nil) + +type fastReflection_Module Module + +func (x *Module) ProtoReflect() protoreflect.Message { + return (*fastReflection_Module)(x) +} + +func (x *Module) slowProtoReflect() protoreflect.Message { + mi := &file_kyve_liquid_module_v1_module_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_Module_messageType fastReflection_Module_messageType +var _ protoreflect.MessageType = fastReflection_Module_messageType{} + +type fastReflection_Module_messageType struct{} + +func (x fastReflection_Module_messageType) Zero() protoreflect.Message { + return (*fastReflection_Module)(nil) +} +func (x fastReflection_Module_messageType) New() protoreflect.Message { + return new(fastReflection_Module) +} +func (x fastReflection_Module_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_Module +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_Module) Descriptor() protoreflect.MessageDescriptor { + return md_Module +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_Module) Type() protoreflect.MessageType { + return _fastReflection_Module_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_Module) New() protoreflect.Message { + return new(fastReflection_Module) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_Module) Interface() protoreflect.ProtoMessage { + return (*Module)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_Module) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Authority != "" { + value := protoreflect.ValueOfString(x.Authority) + if !f(fd_Module_authority, value) { + return + } + } + if x.Bech32PrefixValidator != "" { + value := protoreflect.ValueOfString(x.Bech32PrefixValidator) + if !f(fd_Module_bech32_prefix_validator, value) { + return + } + } + if x.Bech32PrefixConsensus != "" { + value := protoreflect.ValueOfString(x.Bech32PrefixConsensus) + if !f(fd_Module_bech32_prefix_consensus, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_Module) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "kyve.liquid.module.v1.Module.authority": + return x.Authority != "" + case "kyve.liquid.module.v1.Module.bech32_prefix_validator": + return x.Bech32PrefixValidator != "" + case "kyve.liquid.module.v1.Module.bech32_prefix_consensus": + return x.Bech32PrefixConsensus != "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: kyve.liquid.module.v1.Module")) + } + panic(fmt.Errorf("message kyve.liquid.module.v1.Module does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Module) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "kyve.liquid.module.v1.Module.authority": + x.Authority = "" + case "kyve.liquid.module.v1.Module.bech32_prefix_validator": + x.Bech32PrefixValidator = "" + case "kyve.liquid.module.v1.Module.bech32_prefix_consensus": + x.Bech32PrefixConsensus = "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: kyve.liquid.module.v1.Module")) + } + panic(fmt.Errorf("message kyve.liquid.module.v1.Module does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_Module) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "kyve.liquid.module.v1.Module.authority": + value := x.Authority + return protoreflect.ValueOfString(value) + case "kyve.liquid.module.v1.Module.bech32_prefix_validator": + value := x.Bech32PrefixValidator + return protoreflect.ValueOfString(value) + case "kyve.liquid.module.v1.Module.bech32_prefix_consensus": + value := x.Bech32PrefixConsensus + return protoreflect.ValueOfString(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: kyve.liquid.module.v1.Module")) + } + panic(fmt.Errorf("message kyve.liquid.module.v1.Module does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Module) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "kyve.liquid.module.v1.Module.authority": + x.Authority = value.Interface().(string) + case "kyve.liquid.module.v1.Module.bech32_prefix_validator": + x.Bech32PrefixValidator = value.Interface().(string) + case "kyve.liquid.module.v1.Module.bech32_prefix_consensus": + x.Bech32PrefixConsensus = value.Interface().(string) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: kyve.liquid.module.v1.Module")) + } + panic(fmt.Errorf("message kyve.liquid.module.v1.Module does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Module) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "kyve.liquid.module.v1.Module.authority": + panic(fmt.Errorf("field authority of message kyve.liquid.module.v1.Module is not mutable")) + case "kyve.liquid.module.v1.Module.bech32_prefix_validator": + panic(fmt.Errorf("field bech32_prefix_validator of message kyve.liquid.module.v1.Module is not mutable")) + case "kyve.liquid.module.v1.Module.bech32_prefix_consensus": + panic(fmt.Errorf("field bech32_prefix_consensus of message kyve.liquid.module.v1.Module is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: kyve.liquid.module.v1.Module")) + } + panic(fmt.Errorf("message kyve.liquid.module.v1.Module does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_Module) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "kyve.liquid.module.v1.Module.authority": + return protoreflect.ValueOfString("") + case "kyve.liquid.module.v1.Module.bech32_prefix_validator": + return protoreflect.ValueOfString("") + case "kyve.liquid.module.v1.Module.bech32_prefix_consensus": + return protoreflect.ValueOfString("") + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: kyve.liquid.module.v1.Module")) + } + panic(fmt.Errorf("message kyve.liquid.module.v1.Module does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_Module) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in kyve.liquid.module.v1.Module", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_Module) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_Module) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_Module) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_Module) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*Module) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + l = len(x.Authority) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Bech32PrefixValidator) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Bech32PrefixConsensus) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*Module) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if len(x.Bech32PrefixConsensus) > 0 { + i -= len(x.Bech32PrefixConsensus) + copy(dAtA[i:], x.Bech32PrefixConsensus) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Bech32PrefixConsensus))) + i-- + dAtA[i] = 0x1a + } + if len(x.Bech32PrefixValidator) > 0 { + i -= len(x.Bech32PrefixValidator) + copy(dAtA[i:], x.Bech32PrefixValidator) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Bech32PrefixValidator))) + i-- + dAtA[i] = 0x12 + } + if len(x.Authority) > 0 { + i -= len(x.Authority) + copy(dAtA[i:], x.Authority) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Authority))) + i-- + dAtA[i] = 0xa + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*Module) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Module: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Module: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Authority", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Authority = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Bech32PrefixValidator", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Bech32PrefixValidator = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Bech32PrefixConsensus", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Bech32PrefixConsensus = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +// This file was modified from its original version. +// https://github.com/cosmos/gaia/blob/b3583a755ad2947582f8e9c969806b187668ea23/proto/gaia/liquid/module/v1/module.proto +// Modifications made by KYVE, 2025. + +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.27.0 +// protoc (unknown) +// source: kyve/liquid/module/v1/module.proto + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// Module is the config object of the liquid module. +type Module struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // authority defines the custom module authority. If not set, defaults to the + // governance module. + Authority string `protobuf:"bytes,1,opt,name=authority,proto3" json:"authority,omitempty"` + // bech32_prefix_validator is the bech32 validator prefix for the app. + Bech32PrefixValidator string `protobuf:"bytes,2,opt,name=bech32_prefix_validator,json=bech32PrefixValidator,proto3" json:"bech32_prefix_validator,omitempty"` + // bech32_prefix_consensus is the bech32 consensus node prefix for the app. + Bech32PrefixConsensus string `protobuf:"bytes,3,opt,name=bech32_prefix_consensus,json=bech32PrefixConsensus,proto3" json:"bech32_prefix_consensus,omitempty"` +} + +func (x *Module) Reset() { + *x = Module{} + if protoimpl.UnsafeEnabled { + mi := &file_kyve_liquid_module_v1_module_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Module) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Module) ProtoMessage() {} + +// Deprecated: Use Module.ProtoReflect.Descriptor instead. +func (*Module) Descriptor() ([]byte, []int) { + return file_kyve_liquid_module_v1_module_proto_rawDescGZIP(), []int{0} +} + +func (x *Module) GetAuthority() string { + if x != nil { + return x.Authority + } + return "" +} + +func (x *Module) GetBech32PrefixValidator() string { + if x != nil { + return x.Bech32PrefixValidator + } + return "" +} + +func (x *Module) GetBech32PrefixConsensus() string { + if x != nil { + return x.Bech32PrefixConsensus + } + return "" +} + +var File_kyve_liquid_module_v1_module_proto protoreflect.FileDescriptor + +var file_kyve_liquid_module_v1_module_proto_rawDesc = []byte{ + 0x0a, 0x22, 0x6b, 0x79, 0x76, 0x65, 0x2f, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x2f, 0x6d, 0x6f, + 0x64, 0x75, 0x6c, 0x65, 0x2f, 0x76, 0x31, 0x2f, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x15, 0x6b, 0x79, 0x76, 0x65, 0x2e, 0x6c, 0x69, 0x71, 0x75, 0x69, + 0x64, 0x2e, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x1a, 0x20, 0x63, 0x6f, 0x73, + 0x6d, 0x6f, 0x73, 0x2f, 0x61, 0x70, 0x70, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, + 0x2f, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xc5, 0x01, + 0x0a, 0x06, 0x4d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x61, 0x75, 0x74, 0x68, + 0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x75, 0x74, + 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12, 0x36, 0x0a, 0x17, 0x62, 0x65, 0x63, 0x68, 0x33, 0x32, + 0x5f, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, + 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x15, 0x62, 0x65, 0x63, 0x68, 0x33, 0x32, 0x50, + 0x72, 0x65, 0x66, 0x69, 0x78, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x36, + 0x0a, 0x17, 0x62, 0x65, 0x63, 0x68, 0x33, 0x32, 0x5f, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x5f, + 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x15, 0x62, 0x65, 0x63, 0x68, 0x33, 0x32, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x43, 0x6f, 0x6e, + 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x3a, 0x2d, 0xba, 0xc0, 0x96, 0xda, 0x01, 0x27, 0x0a, 0x25, + 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x4b, 0x59, 0x56, 0x45, 0x4e, + 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x2f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x2f, 0x78, 0x2f, 0x6c, + 0x69, 0x71, 0x75, 0x69, 0x64, 0x42, 0xd0, 0x01, 0x0a, 0x19, 0x63, 0x6f, 0x6d, 0x2e, 0x6b, 0x79, + 0x76, 0x65, 0x2e, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x2e, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, + 0x2e, 0x76, 0x31, 0x42, 0x0b, 0x4d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, + 0x50, 0x01, 0x5a, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, + 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x6b, 0x79, 0x76, 0x65, 0x2f, 0x6c, 0x69, 0x71, 0x75, 0x69, 0x64, + 0x2f, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x2f, 0x76, 0x31, 0x3b, 0x6d, 0x6f, 0x64, 0x75, 0x6c, + 0x65, 0x76, 0x31, 0xa2, 0x02, 0x03, 0x4b, 0x4c, 0x4d, 0xaa, 0x02, 0x15, 0x4b, 0x79, 0x76, 0x65, + 0x2e, 0x4c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x2e, 0x4d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x2e, 0x56, + 0x31, 0xca, 0x02, 0x15, 0x4b, 0x79, 0x76, 0x65, 0x5c, 0x4c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x5c, + 0x4d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x5c, 0x56, 0x31, 0xe2, 0x02, 0x21, 0x4b, 0x79, 0x76, 0x65, + 0x5c, 0x4c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x5c, 0x4d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x5c, 0x56, + 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x18, + 0x4b, 0x79, 0x76, 0x65, 0x3a, 0x3a, 0x4c, 0x69, 0x71, 0x75, 0x69, 0x64, 0x3a, 0x3a, 0x4d, 0x6f, + 0x64, 0x75, 0x6c, 0x65, 0x3a, 0x3a, 0x56, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_kyve_liquid_module_v1_module_proto_rawDescOnce sync.Once + file_kyve_liquid_module_v1_module_proto_rawDescData = file_kyve_liquid_module_v1_module_proto_rawDesc +) + +func file_kyve_liquid_module_v1_module_proto_rawDescGZIP() []byte { + file_kyve_liquid_module_v1_module_proto_rawDescOnce.Do(func() { + file_kyve_liquid_module_v1_module_proto_rawDescData = protoimpl.X.CompressGZIP(file_kyve_liquid_module_v1_module_proto_rawDescData) + }) + return file_kyve_liquid_module_v1_module_proto_rawDescData +} + +var file_kyve_liquid_module_v1_module_proto_msgTypes = make([]protoimpl.MessageInfo, 1) +var file_kyve_liquid_module_v1_module_proto_goTypes = []interface{}{ + (*Module)(nil), // 0: kyve.liquid.module.v1.Module +} +var file_kyve_liquid_module_v1_module_proto_depIdxs = []int32{ + 0, // [0:0] is the sub-list for method output_type + 0, // [0:0] is the sub-list for method input_type + 0, // [0:0] is the sub-list for extension type_name + 0, // [0:0] is the sub-list for extension extendee + 0, // [0:0] is the sub-list for field type_name +} + +func init() { file_kyve_liquid_module_v1_module_proto_init() } +func file_kyve_liquid_module_v1_module_proto_init() { + if File_kyve_liquid_module_v1_module_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_kyve_liquid_module_v1_module_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Module); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_kyve_liquid_module_v1_module_proto_rawDesc, + NumEnums: 0, + NumMessages: 1, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_kyve_liquid_module_v1_module_proto_goTypes, + DependencyIndexes: file_kyve_liquid_module_v1_module_proto_depIdxs, + MessageInfos: file_kyve_liquid_module_v1_module_proto_msgTypes, + }.Build() + File_kyve_liquid_module_v1_module_proto = out.File + file_kyve_liquid_module_v1_module_proto_rawDesc = nil + file_kyve_liquid_module_v1_module_proto_goTypes = nil + file_kyve_liquid_module_v1_module_proto_depIdxs = nil +} diff --git a/app/app.go b/app/app.go index 66f57f6e..32cb5bb6 100644 --- a/app/app.go +++ b/app/app.go @@ -83,6 +83,7 @@ import ( funderskeeper "github.com/KYVENetwork/chain/x/funders/keeper" _ "github.com/KYVENetwork/chain/x/global" // import for side-effects globalkeeper "github.com/KYVENetwork/chain/x/global/keeper" + _ "github.com/KYVENetwork/chain/x/liquid" _ "github.com/KYVENetwork/chain/x/multi_coin_rewards" // import for side-effects multicoinrewardskeeper "github.com/KYVENetwork/chain/x/multi_coin_rewards/keeper" _ "github.com/KYVENetwork/chain/x/pool" // import for side-effects @@ -95,6 +96,7 @@ import ( _ "github.com/KYVENetwork/chain/x/team" // import for side-effects teamkeeper "github.com/KYVENetwork/chain/x/team/keeper" // this line is used by starport scaffolding # stargate/app/moduleImport + liquidkeeper "github.com/KYVENetwork/chain/x/liquid/keeper" ) const ( @@ -160,6 +162,9 @@ type App struct { FundersKeeper funderskeeper.Keeper MultiCoinRewardsKeeper multicoinrewardskeeper.Keeper + // Cosmos + LiquidKeeper liquidkeeper.Keeper + // simulation manager // sm *module.SimulationManager } @@ -307,6 +312,8 @@ func New( &app.TeamKeeper, &app.FundersKeeper, &app.MultiCoinRewardsKeeper, + + &app.LiquidKeeper, // this line is used by starport scaffolding # stargate/app/keeperDefinition ); err != nil { panic(err) diff --git a/app/app_config.go b/app/app_config.go index 233feb5e..7134f4ef 100644 --- a/app/app_config.go +++ b/app/app_config.go @@ -63,6 +63,9 @@ import ( hyperlanetypes "github.com/bcp-innovations/hyperlane-cosmos/x/core/types" warptypes "github.com/bcp-innovations/hyperlane-cosmos/x/warp/types" + + liquidmodulev1 "github.com/KYVENetwork/chain/api/kyve/liquid/module/v1" + liquidtypes "github.com/KYVENetwork/chain/x/liquid/types" // this line is used by starport scaffolding # stargate/app/moduleImport ) @@ -107,6 +110,8 @@ var ( teamtypes.ModuleName, funderstypes.ModuleName, multicoinrewardstypes.ModuleName, + + liquidtypes.ModuleName, // this line is used by starport scaffolding # stargate/app/initGenesis } @@ -137,6 +142,8 @@ var ( // KYVE modules stakerstypes.ModuleName, multicoinrewardstypes.ModuleName, + + liquidtypes.ModuleName, // this line is used by starport scaffolding # stargate/app/beginBlockers } @@ -186,6 +193,8 @@ var ( {Account: teamtypes.ModuleName}, {Account: funderstypes.ModuleName}, + {Account: liquidtypes.ModuleName, Permissions: []string{authtypes.Minter, authtypes.Burner}}, + // Hyperlane, {Account: hyperlanetypes.ModuleName}, {Account: warptypes.ModuleName, Permissions: []string{authtypes.Burner, authtypes.Minter}}, @@ -366,6 +375,10 @@ var ( Name: hyperlanetypes.ModuleName, Config: appconfig.WrapAny(&hyperlanemodulev1.Module{}), }, + { + Name: liquidtypes.ModuleName, + Config: appconfig.WrapAny(&liquidmodulev1.Module{}), + }, // this line is used by starport scaffolding # stargate/app/moduleConfig }, }) From f3041ef47cc01d424506013f674a6439e2649cea Mon Sep 17 00:00:00 2001 From: mbreithecker Date: Wed, 30 Jul 2025 16:59:13 +0200 Subject: [PATCH 5/8] chore: small nits --- app/app.go | 2 +- app/app_config.go | 1 + proto/kyve/liquid/v1beta1/query.proto | 24 ++++++++++++------------ 3 files changed, 14 insertions(+), 13 deletions(-) diff --git a/app/app.go b/app/app.go index 32cb5bb6..ba9dc19f 100644 --- a/app/app.go +++ b/app/app.go @@ -163,7 +163,7 @@ type App struct { MultiCoinRewardsKeeper multicoinrewardskeeper.Keeper // Cosmos - LiquidKeeper liquidkeeper.Keeper + LiquidKeeper *liquidkeeper.Keeper // simulation manager // sm *module.SimulationManager diff --git a/app/app_config.go b/app/app_config.go index 7134f4ef..c8a4f1c0 100644 --- a/app/app_config.go +++ b/app/app_config.go @@ -193,6 +193,7 @@ var ( {Account: teamtypes.ModuleName}, {Account: funderstypes.ModuleName}, + // Liquid {Account: liquidtypes.ModuleName, Permissions: []string{authtypes.Minter, authtypes.Burner}}, // Hyperlane, diff --git a/proto/kyve/liquid/v1beta1/query.proto b/proto/kyve/liquid/v1beta1/query.proto index 67606d9c..f758c9ac 100644 --- a/proto/kyve/liquid/v1beta1/query.proto +++ b/proto/kyve/liquid/v1beta1/query.proto @@ -23,64 +23,64 @@ service Query { // gas if the pagination field is incorrectly set. rpc LiquidValidators(QueryLiquidValidatorsRequest) returns (QueryLiquidValidatorsResponse) { option (cosmos.query.v1.module_query_safe) = true; - option (google.api.http).get = "/gaia/liquid/v1beta1/liquid_validators"; + option (google.api.http).get = "/kyve/liquid/v1beta1/liquid_validators"; } // Query for an individual liquid validator by validator address rpc LiquidValidator(QueryLiquidValidatorRequest) returns (QueryLiquidValidatorResponse) { - option (google.api.http).get = "/gaia/liquid/v1beta1/liquid_validator/{validator_addr}"; + option (google.api.http).get = "/kyve/liquid/v1beta1/liquid_validator/{validator_addr}"; } // Query for individual tokenize share record information by share by id rpc TokenizeShareRecordById(QueryTokenizeShareRecordByIdRequest) returns (QueryTokenizeShareRecordByIdResponse) { - option (google.api.http).get = "/gaia/liquid/v1beta1/tokenize_share_record_by_id/{id}"; + option (google.api.http).get = "/kyve/liquid/v1beta1/tokenize_share_record_by_id/{id}"; } // Query for individual tokenize share record information by share denom rpc TokenizeShareRecordByDenom(QueryTokenizeShareRecordByDenomRequest) returns (QueryTokenizeShareRecordByDenomResponse) { - option (google.api.http).get = "/gaia/liquid/v1beta1/tokenize_share_record_by_denom/{denom}"; + option (google.api.http).get = "/kyve/liquid/v1beta1/tokenize_share_record_by_denom/{denom}"; } // Query tokenize share records by address rpc TokenizeShareRecordsOwned(QueryTokenizeShareRecordsOwnedRequest) returns (QueryTokenizeShareRecordsOwnedResponse) { - option (google.api.http).get = "/gaia/liquid/v1beta1/tokenize_share_record_owned/{owner}"; + option (google.api.http).get = "/kyve/liquid/v1beta1/tokenize_share_record_owned/{owner}"; } // Query for all tokenize share records rpc AllTokenizeShareRecords(QueryAllTokenizeShareRecordsRequest) returns (QueryAllTokenizeShareRecordsResponse) { - option (google.api.http).get = "/gaia/liquid/v1beta1/tokenize_share_records"; + option (google.api.http).get = "/kyve/liquid/v1beta1/tokenize_share_records"; } // Query for last tokenize share record id rpc LastTokenizeShareRecordId(QueryLastTokenizeShareRecordIdRequest) returns (QueryLastTokenizeShareRecordIdResponse) { - option (google.api.http).get = "/gaia/liquid/v1beta1/last_tokenize_share_record_id"; + option (google.api.http).get = "/kyve/liquid/v1beta1/last_tokenize_share_record_id"; } // Query for total tokenized staked assets rpc TotalTokenizeSharedAssets(QueryTotalTokenizeSharedAssetsRequest) returns (QueryTotalTokenizeSharedAssetsResponse) { - option (google.api.http).get = "/gaia/liquid/v1beta1/total_tokenize_shared_assets"; + option (google.api.http).get = "/kyve/liquid/v1beta1/total_tokenize_shared_assets"; } // Query for total liquid staked (including tokenized shares or owned by an // liquid staking provider) rpc TotalLiquidStaked(QueryTotalLiquidStaked) returns (QueryTotalLiquidStakedResponse) { - option (google.api.http).get = "/gaia/liquid/v1beta1/total_liquid_staked"; + option (google.api.http).get = "/kyve/liquid/v1beta1/total_liquid_staked"; } // Query tokenize share locks rpc TokenizeShareLockInfo(QueryTokenizeShareLockInfo) returns (QueryTokenizeShareLockInfoResponse) { - option (google.api.http).get = "/gaia/liquid/v1beta1/tokenize_share_lock_info/{address}"; + option (google.api.http).get = "/kyve/liquid/v1beta1/tokenize_share_lock_info/{address}"; } // Parameters queries the liquid parameters. rpc Params(QueryParamsRequest) returns (QueryParamsResponse) { option (cosmos.query.v1.module_query_safe) = true; - option (google.api.http).get = "/gaia/liquid/v1beta1/params"; + option (google.api.http).get = "/kyve/liquid/v1beta1/params"; } // TokenizeShareRecordReward queries the tokenize share record rewards rpc TokenizeShareRecordReward(QueryTokenizeShareRecordRewardRequest) returns (QueryTokenizeShareRecordRewardResponse) { - option (google.api.http).get = "/gaia/liquid/v1beta1/{owner_address}/tokenize_share_record_rewards"; + option (google.api.http).get = "/kyve/liquid/v1beta1/{owner_address}/tokenize_share_record_rewards"; } } From 92f0fba9b2d862da07e48e36a3682f8259a4d9cb Mon Sep 17 00:00:00 2001 From: mbreithecker Date: Wed, 30 Jul 2025 17:07:05 +0200 Subject: [PATCH 6/8] chore: update readme --- CHANGELOG.md | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 43525f17..3c6700e4 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -16,9 +16,13 @@ An '!' indicates a state machine breaking change. ## Unreleased +### Features + +- ! (`x/liquid`) [#267](https://github.com/KYVENetwork/chain/pull/267) Add Cosmos Liquid Staking module. + ### Improvements -- ! [#266](https://github.com/KYVENetwork/chain/pull/266) Improve storage cost payout. +- ! (`x/bundles`) [#266](https://github.com/KYVENetwork/chain/pull/266) Improve storage cost payout. ## [v2.1.0](https://github.com/KYVENetwork/chain/releases/tag/v2.1.0) - 2025-04-29 From 2ef802b99c9ddbbf8e3337e31d061ca0b91ce058 Mon Sep 17 00:00:00 2001 From: mbreithecker Date: Fri, 22 Aug 2025 12:21:39 +0200 Subject: [PATCH 7/8] chore: upgrade migration --- app/app.go | 2 + app/upgrades/v2_2/store.go | 2 +- app/upgrades/v2_2/upgrade.go | 13 + docs/config.json | 13 + docs/static/openapi.yml | 790 +++++++++++++++++++++++++++++ proto/kyve/liquid/v1beta1/tx.proto | 12 +- x/liquid/module.go | 7 +- x/liquid/types/expected_keepers.go | 4 + x/liquid/types/query.pb.go | 60 +-- x/liquid/types/query.pb.gw.go | 24 +- x/liquid/types/tx.pb.go | 116 ++--- 11 files changed, 934 insertions(+), 109 deletions(-) diff --git a/app/app.go b/app/app.go index 69f19ef5..4369f6d5 100644 --- a/app/app.go +++ b/app/app.go @@ -423,6 +423,8 @@ func New( v2_2.CreateUpgradeHandler( app.ModuleManager, app.Configurator(), + app.LiquidKeeper, + app.StakingKeeper, ), ) diff --git a/app/upgrades/v2_2/store.go b/app/upgrades/v2_2/store.go index 8f1de260..1649372e 100644 --- a/app/upgrades/v2_2/store.go +++ b/app/upgrades/v2_2/store.go @@ -8,7 +8,7 @@ import ( func CreateStoreLoader(upgradeHeight int64) baseapp.StoreLoader { storeUpgrades := storetypes.StoreUpgrades{ - Added: []string{""}, + Added: []string{"liquid"}, } return upgradetypes.UpgradeStoreLoader(upgradeHeight, &storeUpgrades) diff --git a/app/upgrades/v2_2/upgrade.go b/app/upgrades/v2_2/upgrade.go index 4a1c0c6b..f55fd469 100644 --- a/app/upgrades/v2_2/upgrade.go +++ b/app/upgrades/v2_2/upgrade.go @@ -4,6 +4,9 @@ import ( "context" "fmt" + liquidkeeper "github.com/KYVENetwork/chain/x/liquid/keeper" + stakingKeeper "github.com/cosmos/cosmos-sdk/x/staking/keeper" + "cosmossdk.io/log" upgradetypes "cosmossdk.io/x/upgrade/types" @@ -20,6 +23,8 @@ var logger log.Logger func CreateUpgradeHandler( mm *module.Manager, configurator module.Configurator, + liquidStakingKeeper *liquidkeeper.Keeper, + stakingKeeper *stakingKeeper.Keeper, ) upgradetypes.UpgradeHandler { return func(ctx context.Context, plan upgradetypes.Plan, fromVM module.VersionMap) (module.VersionMap, error) { sdkCtx := sdk.UnwrapSDKContext(ctx) @@ -30,6 +35,14 @@ func CreateUpgradeHandler( migratedVersionMap, err := mm.RunMigrations(ctx, configurator, fromVM) // Run KYVE migrations + validators, _ := stakingKeeper.GetValidators(ctx, 1_000) + for _, v := range validators { + valAddress, _ := sdk.ValAddressFromBech32(v.OperatorAddress) + err := liquidStakingKeeper.Hooks().AfterValidatorCreated(ctx, valAddress) + if err != nil { + return nil, err + } + } logger.Info(fmt.Sprintf("finished upgrade %v", UpgradeName)) diff --git a/docs/config.json b/docs/config.json index 563db1c2..7025359f 100644 --- a/docs/config.json +++ b/docs/config.json @@ -79,6 +79,19 @@ } } }, + { + "url": "./tmp-swagger-gen/kyve/liquid/v1beta1/query.swagger.json", + "operationIds": { + "rename": { + "Params": "LiquidParams" + } + }, + "tags": { + "rename": { + "Query": "QueryLiquid" + } + } + }, { "url": "./tmp-swagger-gen/cosmos/auth/v1beta1/query.swagger.json", "operationIds": { diff --git a/docs/static/openapi.yml b/docs/static/openapi.yml index 3c0c828d..edd67f26 100644 --- a/docs/static/openapi.yml +++ b/docs/static/openapi.yml @@ -9428,6 +9428,796 @@ paths: format: uint64 tags: - QueryTeam + /kyve/liquid/v1beta1/last_tokenize_share_record_id: + get: + summary: Query for last tokenize share record id + operationId: LastTokenizeShareRecordId + responses: + '200': + description: A successful response. + schema: + type: object + properties: + id: + type: string + format: uint64 + description: |- + QueryLastTokenizeShareRecordIdResponse is response type for the + Query/QueryLastTokenizeShareRecordId RPC method. + default: + description: An unexpected error response. + schema: + type: object + properties: + code: + type: integer + format: int32 + message: + type: string + details: + type: array + items: + type: object + properties: + '@type': + type: string + additionalProperties: {} + tags: + - QueryLiquid + /kyve/liquid/v1beta1/liquid_validator/{validator_addr}: + get: + summary: Query for an individual liquid validator by validator address + operationId: LiquidValidator + responses: + '200': + description: A successful response. + schema: + type: object + properties: + liquid_validator: + type: object + properties: + operator_address: + type: string + description: >- + operator_address defines the address of the validator's + operator; bech + + encoded in JSON. + liquid_shares: + type: string + title: >- + Number of shares either tokenized or owned by a liquid + staking provider + description: >- + LiquidValidator is the storage layout for details about a + validator's liquid + + stake. + description: |- + QueryLiquidValidatorResponse is the response type for the + Query/LiquidValidator RPC method. + default: + description: An unexpected error response. + schema: + type: object + properties: + code: + type: integer + format: int32 + message: + type: string + details: + type: array + items: + type: object + properties: + '@type': + type: string + additionalProperties: {} + parameters: + - name: validator_addr + in: path + required: true + type: string + tags: + - QueryLiquid + /kyve/liquid/v1beta1/liquid_validators: + get: + summary: LiquidValidators queries all liquid validators. + description: >- + When called from another module, this query might consume a high amount + of + + gas if the pagination field is incorrectly set. + operationId: LiquidValidators + responses: + '200': + description: A successful response. + schema: + type: object + properties: + liquid_validators: + type: array + items: + type: object + properties: + operator_address: + type: string + description: >- + operator_address defines the address of the validator's + operator; bech + + encoded in JSON. + liquid_shares: + type: string + title: >- + Number of shares either tokenized or owned by a liquid + staking provider + description: >- + LiquidValidator is the storage layout for details about a + validator's liquid + + stake. + pagination: + description: pagination defines the pagination in the response. + type: object + properties: + next_key: + type: string + format: byte + description: |- + next_key is the key to be passed to PageRequest.key to + query the next page most efficiently. It will be empty if + there are no more results. + total: + type: string + format: uint64 + title: >- + total is total number of results available if + PageRequest.count_total + + was set, its value is undefined otherwise + description: |- + QueryLiquidValidatorsResponse is response type for the + Query/QueryLiquidValidators RPC method. + default: + description: An unexpected error response. + schema: + type: object + properties: + code: + type: integer + format: int32 + message: + type: string + details: + type: array + items: + type: object + properties: + '@type': + type: string + additionalProperties: {} + parameters: + - name: pagination.key + description: |- + key is a value returned in PageResponse.next_key to begin + querying the next page most efficiently. Only one of offset or key + should be set. + in: query + required: false + type: string + format: byte + - name: pagination.offset + description: >- + offset is a numeric offset that can be used when key is unavailable. + + It is less efficient than using key. Only one of offset or key + should + + be set. + in: query + required: false + type: string + format: uint64 + - name: pagination.limit + description: >- + limit is the total number of results to be returned in the result + page. + + If left empty it will default to a value to be set by each app. + in: query + required: false + type: string + format: uint64 + - name: pagination.count_total + description: >- + count_total is set to true to indicate that the result set should + include + + a count of the total number of items available for pagination in + UIs. + + count_total is only respected when offset is used. It is ignored + when key + + is set. + in: query + required: false + type: boolean + - name: pagination.reverse + description: >- + reverse is set to true if results are to be returned in the + descending order. + + + Since: cosmos-sdk 0.43 + in: query + required: false + type: boolean + tags: + - QueryLiquid + /kyve/liquid/v1beta1/params: + get: + summary: Parameters queries the liquid parameters. + operationId: LiquidParams + responses: + '200': + description: A successful response. + schema: + type: object + properties: + params: + description: params holds all the parameters of this module. + type: object + properties: + global_liquid_staking_cap: + type: string + title: >- + global_liquid_staking_cap represents a cap on the portion + of stake that + + comes from liquid staking providers + validator_liquid_staking_cap: + type: string + title: >- + validator_liquid_staking_cap represents a cap on the + portion of stake that + + comes from liquid staking providers for a specific + validator + description: >- + QueryParamsResponse is response type for the Query/Params RPC + method. + default: + description: An unexpected error response. + schema: + type: object + properties: + code: + type: integer + format: int32 + message: + type: string + details: + type: array + items: + type: object + properties: + '@type': + type: string + additionalProperties: {} + tags: + - QueryLiquid + /kyve/liquid/v1beta1/tokenize_share_lock_info/{address}: + get: + summary: Query tokenize share locks + operationId: TokenizeShareLockInfo + responses: + '200': + description: A successful response. + schema: + type: object + properties: + status: + type: string + expiration_time: + type: string + title: |- + QueryTokenizeShareLockInfoResponse is the response from the + QueryTokenizeShareLockInfo query + default: + description: An unexpected error response. + schema: + type: object + properties: + code: + type: integer + format: int32 + message: + type: string + details: + type: array + items: + type: object + properties: + '@type': + type: string + additionalProperties: {} + parameters: + - name: address + in: path + required: true + type: string + tags: + - QueryLiquid + /kyve/liquid/v1beta1/tokenize_share_record_by_denom/{denom}: + get: + summary: Query for individual tokenize share record information by share denom + operationId: TokenizeShareRecordByDenom + responses: + '200': + description: A successful response. + schema: + type: object + properties: + record: + type: object + properties: + id: + type: string + format: uint64 + owner: + type: string + module_account: + type: string + title: module account take the role of delegator + validator: + type: string + title: validator delegated to for tokenize share record creation + title: TokenizeShareRecord represents a tokenized delegation + description: |- + QueryTokenizeShareRecordByDenomResponse is response type for the + Query/QueryTokenizeShareRecordByDenom RPC method. + default: + description: An unexpected error response. + schema: + type: object + properties: + code: + type: integer + format: int32 + message: + type: string + details: + type: array + items: + type: object + properties: + '@type': + type: string + additionalProperties: {} + parameters: + - name: denom + in: path + required: true + type: string + tags: + - QueryLiquid + /kyve/liquid/v1beta1/tokenize_share_record_by_id/{id}: + get: + summary: Query for individual tokenize share record information by share by id + operationId: TokenizeShareRecordById + responses: + '200': + description: A successful response. + schema: + type: object + properties: + record: + type: object + properties: + id: + type: string + format: uint64 + owner: + type: string + module_account: + type: string + title: module account take the role of delegator + validator: + type: string + title: validator delegated to for tokenize share record creation + title: TokenizeShareRecord represents a tokenized delegation + description: |- + QueryTokenizeShareRecordByIdRequest is response type for the + Query/QueryTokenizeShareRecordById RPC method. + default: + description: An unexpected error response. + schema: + type: object + properties: + code: + type: integer + format: int32 + message: + type: string + details: + type: array + items: + type: object + properties: + '@type': + type: string + additionalProperties: {} + parameters: + - name: id + in: path + required: true + type: string + format: uint64 + tags: + - QueryLiquid + /kyve/liquid/v1beta1/tokenize_share_record_owned/{owner}: + get: + summary: Query tokenize share records by address + operationId: TokenizeShareRecordsOwned + responses: + '200': + description: A successful response. + schema: + type: object + properties: + records: + type: array + items: + type: object + properties: + id: + type: string + format: uint64 + owner: + type: string + module_account: + type: string + title: module account take the role of delegator + validator: + type: string + title: >- + validator delegated to for tokenize share record + creation + title: TokenizeShareRecord represents a tokenized delegation + description: |- + QueryTokenizeShareRecordsOwnedResponse is response type for the + Query/QueryTokenizeShareRecordsOwned RPC method. + default: + description: An unexpected error response. + schema: + type: object + properties: + code: + type: integer + format: int32 + message: + type: string + details: + type: array + items: + type: object + properties: + '@type': + type: string + additionalProperties: {} + parameters: + - name: owner + in: path + required: true + type: string + tags: + - QueryLiquid + /kyve/liquid/v1beta1/tokenize_share_records: + get: + summary: Query for all tokenize share records + operationId: AllTokenizeShareRecords + responses: + '200': + description: A successful response. + schema: + type: object + properties: + records: + type: array + items: + type: object + properties: + id: + type: string + format: uint64 + owner: + type: string + module_account: + type: string + title: module account take the role of delegator + validator: + type: string + title: >- + validator delegated to for tokenize share record + creation + title: TokenizeShareRecord represents a tokenized delegation + pagination: + description: pagination defines the pagination in the response. + type: object + properties: + next_key: + type: string + format: byte + description: |- + next_key is the key to be passed to PageRequest.key to + query the next page most efficiently. It will be empty if + there are no more results. + total: + type: string + format: uint64 + title: >- + total is total number of results available if + PageRequest.count_total + + was set, its value is undefined otherwise + description: |- + QueryAllTokenizeShareRecordsResponse is response type for the + Query/QueryAllTokenizeShareRecords RPC method. + default: + description: An unexpected error response. + schema: + type: object + properties: + code: + type: integer + format: int32 + message: + type: string + details: + type: array + items: + type: object + properties: + '@type': + type: string + additionalProperties: {} + parameters: + - name: pagination.key + description: |- + key is a value returned in PageResponse.next_key to begin + querying the next page most efficiently. Only one of offset or key + should be set. + in: query + required: false + type: string + format: byte + - name: pagination.offset + description: >- + offset is a numeric offset that can be used when key is unavailable. + + It is less efficient than using key. Only one of offset or key + should + + be set. + in: query + required: false + type: string + format: uint64 + - name: pagination.limit + description: >- + limit is the total number of results to be returned in the result + page. + + If left empty it will default to a value to be set by each app. + in: query + required: false + type: string + format: uint64 + - name: pagination.count_total + description: >- + count_total is set to true to indicate that the result set should + include + + a count of the total number of items available for pagination in + UIs. + + count_total is only respected when offset is used. It is ignored + when key + + is set. + in: query + required: false + type: boolean + - name: pagination.reverse + description: >- + reverse is set to true if results are to be returned in the + descending order. + + + Since: cosmos-sdk 0.43 + in: query + required: false + type: boolean + tags: + - QueryLiquid + /kyve/liquid/v1beta1/total_liquid_staked: + get: + summary: |- + Query for total liquid staked (including tokenized shares or owned by an + liquid staking provider) + operationId: TotalLiquidStaked + responses: + '200': + description: A successful response. + schema: + type: object + properties: + tokens: + type: string + description: |- + QueryTotalLiquidStakedResponse is response type for the + Query/QueryQueryTotalLiquidStaked RPC method. + default: + description: An unexpected error response. + schema: + type: object + properties: + code: + type: integer + format: int32 + message: + type: string + details: + type: array + items: + type: object + properties: + '@type': + type: string + additionalProperties: {} + tags: + - QueryLiquid + /kyve/liquid/v1beta1/total_tokenize_shared_assets: + get: + summary: Query for total tokenized staked assets + operationId: TotalTokenizeSharedAssets + responses: + '200': + description: A successful response. + schema: + type: object + properties: + value: + type: object + properties: + denom: + type: string + amount: + type: string + description: >- + Coin defines a token with a denomination and an amount. + + + NOTE: The amount field is an Int which implements the custom + method + + signatures required by gogoproto. + description: |- + QueryTotalTokenizeSharedAssetsResponse is response type for the + Query/QueryTotalTokenizeSharedAssets RPC method. + default: + description: An unexpected error response. + schema: + type: object + properties: + code: + type: integer + format: int32 + message: + type: string + details: + type: array + items: + type: object + properties: + '@type': + type: string + additionalProperties: {} + tags: + - QueryLiquid + /kyve/liquid/v1beta1/{owner_address}/tokenize_share_record_rewards: + get: + summary: TokenizeShareRecordReward queries the tokenize share record rewards + operationId: TokenizeShareRecordReward + responses: + '200': + description: A successful response. + schema: + type: object + properties: + rewards: + type: array + items: + type: object + properties: + record_id: + type: string + format: uint64 + reward: + type: array + items: + type: object + properties: + denom: + type: string + amount: + type: string + description: >- + DecCoin defines a token with a denomination and a + decimal amount. + + + NOTE: The amount field is an Dec which implements the + custom method + + signatures required by gogoproto. + title: >- + TokenizeShareRecordReward represents the properties of + tokenize share + description: rewards defines all the rewards accrued by a delegator. + total: + type: array + items: + type: object + properties: + denom: + type: string + amount: + type: string + description: >- + DecCoin defines a token with a denomination and a decimal + amount. + + + NOTE: The amount field is an Dec which implements the custom + method + + signatures required by gogoproto. + description: total defines the sum of all the rewards. + description: >- + QueryTokenizeShareRecordRewardResponse is the response type for + the + + Query/TokenizeShareRecordReward RPC method. + default: + description: An unexpected error response. + schema: + type: object + properties: + code: + type: integer + format: int32 + message: + type: string + details: + type: array + items: + type: object + properties: + '@type': + type: string + additionalProperties: {} + parameters: + - name: owner_address + in: path + required: true + type: string + tags: + - QueryLiquid /cosmos/auth/v1beta1/account_info/{address}: get: summary: AccountInfo queries account info which is common to all account types. diff --git a/proto/kyve/liquid/v1beta1/tx.proto b/proto/kyve/liquid/v1beta1/tx.proto index ebdb62bc..2a57e14e 100644 --- a/proto/kyve/liquid/v1beta1/tx.proto +++ b/proto/kyve/liquid/v1beta1/tx.proto @@ -95,7 +95,7 @@ message MsgTokenizeSharesResponse { // delegation message MsgRedeemTokensForShares { option (cosmos.msg.v1.signer) = "delegator_address"; - option (amino.name) = "gaia/MsgRedeemTokensForShares"; + option (amino.name) = "kyve/MsgRedeemTokensForShares"; option (gogoproto.equal) = false; option (gogoproto.goproto_getters) = false; @@ -113,7 +113,7 @@ message MsgRedeemTokensForSharesResponse { // MsgTransferTokenizeShareRecord transfer a tokenize share record message MsgTransferTokenizeShareRecord { option (cosmos.msg.v1.signer) = "sender"; - option (amino.name) = "gaia/MsgTransferTokenizeShareRecord"; + option (amino.name) = "kyve/MsgTransferTokenizeShareRecord"; option (gogoproto.equal) = false; option (gogoproto.goproto_getters) = false; @@ -131,7 +131,7 @@ message MsgTransferTokenizeShareRecordResponse {} // address message MsgDisableTokenizeShares { option (cosmos.msg.v1.signer) = "delegator_address"; - option (amino.name) = "gaia/MsgDisableTokenizeShares"; + option (amino.name) = "kyve/MsgDisableTokenizeShares"; option (gogoproto.equal) = false; option (gogoproto.goproto_getters) = false; @@ -146,7 +146,7 @@ message MsgDisableTokenizeSharesResponse {} // MsgEnableTokenizeShares re-enables tokenization of shares for a given address message MsgEnableTokenizeShares { option (cosmos.msg.v1.signer) = "delegator_address"; - option (amino.name) = "gaia/MsgEnableTokenizeShares"; + option (amino.name) = "kyve/MsgEnableTokenizeShares"; option (gogoproto.equal) = false; option (gogoproto.goproto_getters) = false; @@ -167,7 +167,7 @@ message MsgEnableTokenizeSharesResponse { // specific record message MsgWithdrawTokenizeShareRecordReward { option (cosmos.msg.v1.signer) = "owner_address"; - option (amino.name) = "gaia/MsgWithdrawTokenizeShareRecordReward"; + option (amino.name) = "kyve/MsgWithdrawTokenizeShareRecordReward"; option (gogoproto.equal) = false; option (gogoproto.goproto_getters) = false; @@ -184,7 +184,7 @@ message MsgWithdrawTokenizeShareRecordRewardResponse {} // all records owned by the designated owner message MsgWithdrawAllTokenizeShareRecordReward { option (cosmos.msg.v1.signer) = "owner_address"; - option (amino.name) = "gaia/MsgWithdrawAllTokenizeShareRecordReward"; + option (amino.name) = "kyve/MsgWithdrawAllTokenizeShareRecordReward"; option (gogoproto.equal) = false; option (gogoproto.goproto_getters) = false; diff --git a/x/liquid/module.go b/x/liquid/module.go index 32f0c7b9..5b82cf53 100644 --- a/x/liquid/module.go +++ b/x/liquid/module.go @@ -9,6 +9,8 @@ import ( "encoding/json" "fmt" + stakingTypes "github.com/cosmos/cosmos-sdk/x/staking/types" + "cosmossdk.io/core/store" "cosmossdk.io/depinject" @@ -193,6 +195,7 @@ type ModuleOutputs struct { LiquidKeeper *keeper.Keeper Module appmodule.AppModule + Hooks stakingTypes.StakingHooksWrapper } func ProvideModule(in ModuleInputs) ModuleOutputs { @@ -216,8 +219,8 @@ func ProvideModule(in ModuleInputs) ModuleOutputs { k, in.AccountKeeper, in.BankKeeper, - stakingKeeper.Keeper{}, + in.StakingKeeper, ) - return ModuleOutputs{LiquidKeeper: k, Module: m} + return ModuleOutputs{LiquidKeeper: k, Module: m, Hooks: stakingTypes.StakingHooksWrapper{StakingHooks: k.Hooks()}} } diff --git a/x/liquid/types/expected_keepers.go b/x/liquid/types/expected_keepers.go index 1166d6c4..d7f5aa86 100644 --- a/x/liquid/types/expected_keepers.go +++ b/x/liquid/types/expected_keepers.go @@ -1,3 +1,7 @@ +// This file was modified from its original version. +// https://github.com/cosmos/gaia/blob/b3583a755ad2947582f8e9c969806b187668ea23/x/liquid/keeper/params.go +// Modifications made by KYVE, 2025. + package types import ( diff --git a/x/liquid/types/query.pb.go b/x/liquid/types/query.pb.go index eafc8105..4acd3957 100644 --- a/x/liquid/types/query.pb.go +++ b/x/liquid/types/query.pb.go @@ -1177,7 +1177,7 @@ func init() { func init() { proto.RegisterFile("kyve/liquid/v1beta1/query.proto", fileDescriptor_1a9d927347bb19fc) } var fileDescriptor_1a9d927347bb19fc = []byte{ - // 1341 bytes of a gzipped FileDescriptorProto + // 1338 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x58, 0xcd, 0x6f, 0x1b, 0xc5, 0x1b, 0xf6, 0xe6, 0xd7, 0xa4, 0xbf, 0x0e, 0xf4, 0x6b, 0x1a, 0x5a, 0x77, 0xd3, 0xda, 0xd5, 0xd0, 0xd6, 0x56, 0xa2, 0x7a, 0x9b, 0x98, 0x34, 0x5f, 0x24, 0x90, 0x34, 0x2d, 0x14, 0xa2, 0x52, 0xdc, @@ -1233,35 +1233,35 @@ var fileDescriptor_1a9d927347bb19fc = []byte{ 0xad, 0x6a, 0x52, 0x17, 0x89, 0x8f, 0x2b, 0xcc, 0x28, 0x6b, 0x4e, 0xa3, 0x46, 0x98, 0xe7, 0xc3, 0x0a, 0x22, 0xfe, 0xc4, 0x77, 0x10, 0x0c, 0x72, 0x8e, 0xf0, 0x2b, 0x05, 0x9c, 0xe8, 0x7c, 0xa8, 0xe1, 0x78, 0x28, 0x8d, 0x38, 0xf5, 0xa0, 0x4e, 0xf4, 0xe3, 0x22, 0xb6, 0x0f, 0xe5, 0x1f, 0xbb, - 0x4f, 0xe0, 0xc7, 0xbf, 0xfc, 0xf5, 0xd9, 0x40, 0x16, 0x5e, 0xd6, 0x4a, 0xd8, 0xc4, 0xe1, 0x1a, - 0xac, 0x4d, 0x27, 0xc0, 0x6f, 0x14, 0x70, 0xbc, 0x23, 0x22, 0xbc, 0xda, 0x73, 0x72, 0x0f, 0xee, - 0x78, 0x1f, 0x1e, 0x12, 0xed, 0x02, 0x07, 0x3a, 0x0d, 0xaf, 0xf5, 0x04, 0x54, 0x6b, 0x06, 0xf5, - 0x60, 0x0b, 0xfe, 0xa4, 0x80, 0x33, 0x11, 0xcf, 0x34, 0x9c, 0x8e, 0x86, 0x13, 0x2f, 0x08, 0xd4, - 0x99, 0x7d, 0x78, 0x4a, 0x42, 0xf3, 0x9c, 0xd0, 0x14, 0x9c, 0x0c, 0x25, 0xe4, 0x48, 0x6f, 0x9d, - 0xb9, 0xee, 0xba, 0xb8, 0xb8, 0xf5, 0xd5, 0x86, 0x6e, 0x1a, 0x5a, 0xd3, 0x34, 0x5a, 0xf0, 0x77, - 0x05, 0xa8, 0xd1, 0xcf, 0x38, 0x9c, 0xeb, 0x13, 0x58, 0xbb, 0x78, 0x50, 0x5f, 0xdf, 0x9f, 0xb3, - 0x24, 0x76, 0x9d, 0x13, 0x9b, 0x87, 0x73, 0xfd, 0x11, 0xe3, 0x0a, 0x45, 0x6b, 0xf2, 0x8f, 0x16, - 0xfc, 0x55, 0x01, 0x67, 0x23, 0xdf, 0x7c, 0x38, 0xdb, 0x17, 0xc0, 0x80, 0xce, 0x50, 0xe7, 0xf6, - 0xe5, 0x2b, 0xb9, 0xbd, 0xc9, 0xb9, 0xcd, 0xc2, 0xe9, 0x3e, 0xb8, 0xb9, 0x17, 0x9d, 0xa1, 0x35, - 0xf9, 0x7d, 0xd7, 0x82, 0x3f, 0x28, 0xe0, 0x4c, 0xc4, 0x43, 0x1f, 0x57, 0x87, 0xf1, 0x5a, 0x24, - 0xae, 0x0e, 0xbb, 0xa8, 0x0a, 0x94, 0xe7, 0x94, 0xae, 0xc0, 0xb1, 0xde, 0x29, 0x31, 0xb8, 0xad, - 0x80, 0xb3, 0x91, 0x4f, 0x79, 0xdc, 0xf1, 0x74, 0x13, 0x0a, 0x71, 0xc7, 0xd3, 0x55, 0x3b, 0xa0, - 0x59, 0xce, 0xe5, 0x35, 0x38, 0x11, 0x7e, 0x49, 0x60, 0xe6, 0xe8, 0xe1, 0x67, 0x64, 0x1a, 0xf0, - 0x67, 0x5e, 0x71, 0x11, 0xd2, 0x21, 0xbe, 0xe2, 0xe2, 0x85, 0x49, 0x7c, 0xc5, 0x75, 0xd1, 0x2a, - 0x68, 0x86, 0x53, 0xca, 0xc3, 0xf1, 0x88, 0xe3, 0x71, 0x70, 0xa5, 0x83, 0x93, 0xa1, 0x63, 0x81, - 0xf9, 0x73, 0x05, 0x9c, 0x7c, 0x41, 0x91, 0xc0, 0xb1, 0x2e, 0x68, 0xda, 0x8d, 0xd5, 0x7c, 0x1f, - 0xc6, 0x3e, 0xe4, 0xab, 0x1c, 0xf2, 0x28, 0xcc, 0xc6, 0x40, 0x96, 0x17, 0x36, 0x13, 0x98, 0xbe, - 0x57, 0xc0, 0x2b, 0xe1, 0x0a, 0x48, 0xeb, 0xb1, 0x5b, 0x3d, 0x07, 0x75, 0xaa, 0x4f, 0x07, 0x1f, - 0xf5, 0x1b, 0x1c, 0xf5, 0x0c, 0x9c, 0xea, 0xa5, 0x0f, 0x2a, 0xb4, 0x58, 0xd6, 0x4d, 0x6b, 0x8d, - 0x6a, 0x4d, 0xa9, 0x68, 0x5a, 0xf0, 0x13, 0x05, 0x0c, 0x89, 0x5f, 0x98, 0x30, 0x13, 0x0d, 0x22, - 0xf0, 0x73, 0x56, 0xcd, 0x76, 0x37, 0x94, 0xf0, 0xb2, 0x7b, 0xaf, 0xf5, 0x79, 0x38, 0x12, 0x8a, - 0x51, 0xfc, 0x96, 0x85, 0xcf, 0xc3, 0xaf, 0x4e, 0xa1, 0x79, 0xfa, 0xbc, 0x3a, 0x03, 0x22, 0xaf, - 0xcf, 0xab, 0x33, 0xa8, 0xd6, 0xd0, 0x3b, 0x1c, 0xfb, 0x32, 0x5c, 0x0a, 0xc5, 0xde, 0x0c, 0xc8, - 0xc3, 0x56, 0xc4, 0x55, 0x2a, 0x95, 0xda, 0xd2, 0x8d, 0xa7, 0x3b, 0x29, 0x65, 0x7b, 0x27, 0xa5, - 0x3c, 0xdf, 0x49, 0x29, 0x9f, 0xee, 0xa6, 0x12, 0xdb, 0xbb, 0xa9, 0xc4, 0x6f, 0xbb, 0xa9, 0xc4, - 0x83, 0x76, 0x39, 0xf6, 0xee, 0x87, 0xf7, 0x6f, 0xdc, 0x26, 0xce, 0x16, 0xb5, 0xcb, 0x5a, 0x71, - 0x1d, 0x9b, 0x96, 0xf6, 0xd0, 0x4b, 0xcb, 0x75, 0xd9, 0xea, 0x10, 0xff, 0xe7, 0x52, 0xfe, 0xbf, - 0x00, 0x00, 0x00, 0xff, 0xff, 0xe4, 0x7e, 0xa8, 0xd8, 0x66, 0x13, 0x00, 0x00, + 0x4f, 0xe0, 0xc7, 0xbf, 0xfc, 0xf5, 0xd9, 0x40, 0x16, 0x5e, 0xd6, 0xa2, 0x35, 0x58, 0x9b, 0x4e, + 0x80, 0xdf, 0x28, 0xe0, 0x78, 0x47, 0x44, 0x78, 0xb5, 0xe7, 0xe4, 0x1e, 0xdc, 0xf1, 0x3e, 0x3c, + 0x24, 0xda, 0x05, 0x0e, 0x74, 0x1a, 0x5e, 0xeb, 0x09, 0xa8, 0xd6, 0x0c, 0xea, 0xc1, 0x16, 0xfc, + 0x49, 0x01, 0x67, 0x22, 0x9e, 0x69, 0x38, 0x1d, 0x0d, 0x27, 0x5e, 0x10, 0xa8, 0x33, 0xfb, 0xf0, + 0x94, 0x84, 0xe6, 0x39, 0xa1, 0x29, 0x38, 0x19, 0x4a, 0xc8, 0x91, 0xde, 0x3a, 0x73, 0xdd, 0x75, + 0x71, 0x71, 0xeb, 0xab, 0x0d, 0xdd, 0x34, 0xb4, 0xa6, 0x69, 0xb4, 0xe0, 0xef, 0x0a, 0x50, 0xa3, + 0x9f, 0x71, 0x38, 0xd7, 0x27, 0xb0, 0x76, 0xf1, 0xa0, 0xbe, 0xbe, 0x3f, 0x67, 0x49, 0xec, 0x3a, + 0x27, 0x36, 0x0f, 0xe7, 0xfa, 0x23, 0xc6, 0x15, 0x8a, 0xd6, 0xe4, 0x1f, 0x2d, 0xf8, 0xab, 0x02, + 0xce, 0x46, 0xbe, 0xf9, 0x70, 0xb6, 0x2f, 0x80, 0x01, 0x9d, 0xa1, 0xce, 0xed, 0xcb, 0x57, 0x72, + 0x7b, 0x93, 0x73, 0x9b, 0x85, 0xd3, 0x7d, 0x70, 0x73, 0x2f, 0x3a, 0x43, 0x6b, 0xf2, 0xfb, 0xae, + 0x05, 0x7f, 0x50, 0xc0, 0x99, 0x88, 0x87, 0x3e, 0xae, 0x0e, 0xe3, 0xb5, 0x48, 0x5c, 0x1d, 0x76, + 0x51, 0x15, 0x28, 0xcf, 0x29, 0x5d, 0x81, 0x63, 0xbd, 0x53, 0x62, 0x70, 0x5b, 0x01, 0x67, 0x23, + 0x9f, 0xf2, 0xb8, 0xe3, 0xe9, 0x26, 0x14, 0xe2, 0x8e, 0xa7, 0xab, 0x76, 0x40, 0xb3, 0x9c, 0xcb, + 0x6b, 0x70, 0x22, 0xfc, 0x92, 0xc0, 0xcc, 0xd1, 0xc3, 0xcf, 0xc8, 0x34, 0xe0, 0xcf, 0xbc, 0xe2, + 0x22, 0xa4, 0x43, 0x7c, 0xc5, 0xc5, 0x0b, 0x93, 0xf8, 0x8a, 0xeb, 0xa2, 0x55, 0xd0, 0x0c, 0xa7, + 0x94, 0x87, 0xe3, 0x11, 0xc7, 0xe3, 0xe0, 0x4a, 0x07, 0x27, 0x43, 0xc7, 0x02, 0xf3, 0xe7, 0x0a, + 0x38, 0xf9, 0x82, 0x22, 0x81, 0x63, 0x5d, 0xd0, 0xb4, 0x1b, 0xab, 0xf9, 0x3e, 0x8c, 0x7d, 0xc8, + 0x57, 0x39, 0xe4, 0x51, 0x98, 0x8d, 0x81, 0x2c, 0x2f, 0x6c, 0x26, 0x30, 0x7d, 0xaf, 0x80, 0x57, + 0xc2, 0x15, 0x90, 0xd6, 0x63, 0xb7, 0x7a, 0x0e, 0xea, 0x54, 0x9f, 0x0e, 0x3e, 0xea, 0x37, 0x38, + 0xea, 0x19, 0x38, 0xd5, 0x4b, 0x1f, 0x54, 0x68, 0xb1, 0xac, 0x9b, 0xd6, 0x1a, 0xd5, 0x9a, 0x52, + 0xd1, 0xb4, 0xe0, 0x27, 0x0a, 0x18, 0x12, 0xbf, 0x30, 0x61, 0x26, 0x1a, 0x44, 0xe0, 0xe7, 0xac, + 0x9a, 0xed, 0x6e, 0x28, 0xe1, 0x65, 0xf7, 0x5e, 0xeb, 0xf3, 0x70, 0x24, 0x14, 0xa3, 0xf8, 0x2d, + 0x0b, 0x9f, 0x87, 0x5f, 0x9d, 0x42, 0xf3, 0xf4, 0x79, 0x75, 0x06, 0x44, 0x5e, 0x9f, 0x57, 0x67, + 0x50, 0xad, 0xa1, 0x77, 0x38, 0xf6, 0x65, 0xb8, 0x14, 0x8a, 0xbd, 0x19, 0x90, 0x87, 0xad, 0x88, + 0xab, 0x54, 0x2a, 0xb5, 0xa5, 0x1b, 0x4f, 0x77, 0x52, 0xca, 0xf6, 0x4e, 0x4a, 0x79, 0xbe, 0x93, + 0x52, 0x3e, 0xdd, 0x4d, 0x25, 0xb6, 0x77, 0x53, 0x89, 0xdf, 0x76, 0x53, 0x89, 0x07, 0xed, 0x72, + 0xec, 0xdd, 0x0f, 0xef, 0xdf, 0xb8, 0x4d, 0x9c, 0x2d, 0x6a, 0x97, 0xb5, 0xe2, 0x3a, 0x36, 0x2d, + 0xed, 0xa1, 0x97, 0x96, 0xeb, 0xb2, 0xd5, 0x21, 0xfe, 0xcf, 0xa5, 0xfc, 0x7f, 0x01, 0x00, 0x00, + 0xff, 0xff, 0x9a, 0xfc, 0xcc, 0xaf, 0x66, 0x13, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. diff --git a/x/liquid/types/query.pb.gw.go b/x/liquid/types/query.pb.gw.go index 41b6ec20..a1cd2af7 100644 --- a/x/liquid/types/query.pb.gw.go +++ b/x/liquid/types/query.pb.gw.go @@ -1068,29 +1068,29 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie } var ( - pattern_Query_LiquidValidators_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gaia", "liquid", "v1beta1", "liquid_validators"}, "", runtime.AssumeColonVerbOpt(true))) + pattern_Query_LiquidValidators_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"kyve", "liquid", "v1beta1", "liquid_validators"}, "", runtime.AssumeColonVerbOpt(true))) - pattern_Query_LiquidValidator_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"gaia", "liquid", "v1beta1", "liquid_validator", "validator_addr"}, "", runtime.AssumeColonVerbOpt(true))) + pattern_Query_LiquidValidator_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"kyve", "liquid", "v1beta1", "liquid_validator", "validator_addr"}, "", runtime.AssumeColonVerbOpt(true))) - pattern_Query_TokenizeShareRecordById_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"gaia", "liquid", "v1beta1", "tokenize_share_record_by_id", "id"}, "", runtime.AssumeColonVerbOpt(true))) + pattern_Query_TokenizeShareRecordById_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"kyve", "liquid", "v1beta1", "tokenize_share_record_by_id", "id"}, "", runtime.AssumeColonVerbOpt(true))) - pattern_Query_TokenizeShareRecordByDenom_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"gaia", "liquid", "v1beta1", "tokenize_share_record_by_denom", "denom"}, "", runtime.AssumeColonVerbOpt(true))) + pattern_Query_TokenizeShareRecordByDenom_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"kyve", "liquid", "v1beta1", "tokenize_share_record_by_denom", "denom"}, "", runtime.AssumeColonVerbOpt(true))) - pattern_Query_TokenizeShareRecordsOwned_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"gaia", "liquid", "v1beta1", "tokenize_share_record_owned", "owner"}, "", runtime.AssumeColonVerbOpt(true))) + pattern_Query_TokenizeShareRecordsOwned_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"kyve", "liquid", "v1beta1", "tokenize_share_record_owned", "owner"}, "", runtime.AssumeColonVerbOpt(true))) - pattern_Query_AllTokenizeShareRecords_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gaia", "liquid", "v1beta1", "tokenize_share_records"}, "", runtime.AssumeColonVerbOpt(true))) + pattern_Query_AllTokenizeShareRecords_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"kyve", "liquid", "v1beta1", "tokenize_share_records"}, "", runtime.AssumeColonVerbOpt(true))) - pattern_Query_LastTokenizeShareRecordId_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gaia", "liquid", "v1beta1", "last_tokenize_share_record_id"}, "", runtime.AssumeColonVerbOpt(true))) + pattern_Query_LastTokenizeShareRecordId_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"kyve", "liquid", "v1beta1", "last_tokenize_share_record_id"}, "", runtime.AssumeColonVerbOpt(true))) - pattern_Query_TotalTokenizeSharedAssets_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gaia", "liquid", "v1beta1", "total_tokenize_shared_assets"}, "", runtime.AssumeColonVerbOpt(true))) + pattern_Query_TotalTokenizeSharedAssets_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"kyve", "liquid", "v1beta1", "total_tokenize_shared_assets"}, "", runtime.AssumeColonVerbOpt(true))) - pattern_Query_TotalLiquidStaked_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gaia", "liquid", "v1beta1", "total_liquid_staked"}, "", runtime.AssumeColonVerbOpt(true))) + pattern_Query_TotalLiquidStaked_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"kyve", "liquid", "v1beta1", "total_liquid_staked"}, "", runtime.AssumeColonVerbOpt(true))) - pattern_Query_TokenizeShareLockInfo_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"gaia", "liquid", "v1beta1", "tokenize_share_lock_info", "address"}, "", runtime.AssumeColonVerbOpt(true))) + pattern_Query_TokenizeShareLockInfo_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"kyve", "liquid", "v1beta1", "tokenize_share_lock_info", "address"}, "", runtime.AssumeColonVerbOpt(true))) - pattern_Query_Params_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gaia", "liquid", "v1beta1", "params"}, "", runtime.AssumeColonVerbOpt(true))) + pattern_Query_Params_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"kyve", "liquid", "v1beta1", "params"}, "", runtime.AssumeColonVerbOpt(true))) - pattern_Query_TokenizeShareRecordReward_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 2, 4}, []string{"gaia", "liquid", "v1beta1", "owner_address", "tokenize_share_record_rewards"}, "", runtime.AssumeColonVerbOpt(true))) + pattern_Query_TokenizeShareRecordReward_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 2, 4}, []string{"kyve", "liquid", "v1beta1", "owner_address", "tokenize_share_record_rewards"}, "", runtime.AssumeColonVerbOpt(true))) ) var ( diff --git a/x/liquid/types/tx.pb.go b/x/liquid/types/tx.pb.go index 50ba4345..79d9d167 100644 --- a/x/liquid/types/tx.pb.go +++ b/x/liquid/types/tx.pb.go @@ -739,65 +739,65 @@ var fileDescriptor_a63931950704005e = []byte{ 0x04, 0x1c, 0xac, 0xb1, 0x77, 0xba, 0x5e, 0xc5, 0xbb, 0x63, 0x66, 0xd6, 0x71, 0x53, 0x09, 0x09, 0x71, 0x42, 0x5c, 0xe8, 0x4f, 0x28, 0x07, 0x04, 0xe2, 0x94, 0x03, 0x08, 0xf1, 0x0f, 0x2a, 0xc1, 0xa1, 0x70, 0xe2, 0x14, 0xaa, 0xe4, 0x10, 0xce, 0xfd, 0x05, 0x68, 0x66, 0x67, 0xd7, 0x5f, 0xbb, - 0xfe, 0x68, 0xc9, 0x25, 0xf1, 0xcc, 0xfb, 0xbc, 0xef, 0xbc, 0xcf, 0x33, 0xcf, 0xcc, 0xd8, 0x70, + 0xfe, 0x68, 0xc9, 0x25, 0xf1, 0xcc, 0xf3, 0xbc, 0xef, 0xbc, 0xcf, 0x33, 0xef, 0xcc, 0xd8, 0x70, 0x61, 0x7b, 0x77, 0x07, 0x1b, 0x75, 0xe7, 0xf3, 0xa6, 0x63, 0x19, 0x3b, 0x6b, 0x15, 0xec, 0xa3, - 0x35, 0xc3, 0xbf, 0xad, 0x37, 0x28, 0xf1, 0x89, 0x72, 0x86, 0x47, 0xf5, 0x20, 0xaa, 0xcb, 0xa8, - 0x3a, 0x8b, 0x5c, 0xc7, 0x23, 0x86, 0xf8, 0x1b, 0xe0, 0xd4, 0x5c, 0x95, 0x30, 0x97, 0x30, 0xa3, - 0x82, 0x18, 0x8e, 0xaa, 0x54, 0x89, 0xe3, 0xc9, 0xf8, 0x79, 0x19, 0x77, 0x99, 0x6d, 0xec, 0xac, - 0xf1, 0x7f, 0x32, 0x30, 0x1f, 0x04, 0xca, 0x62, 0x64, 0x04, 0x03, 0x19, 0x9a, 0xb3, 0x89, 0x4d, - 0x82, 0x79, 0xfe, 0x49, 0xce, 0xe6, 0x6d, 0x42, 0xec, 0x3a, 0x36, 0xc4, 0xa8, 0xd2, 0xbc, 0x65, - 0xf8, 0x8e, 0x8b, 0x99, 0x8f, 0xdc, 0x86, 0x04, 0x2c, 0xc6, 0x11, 0x92, 0x0c, 0x04, 0x42, 0xfb, - 0x0d, 0xc0, 0x53, 0x25, 0x66, 0x7f, 0xd8, 0xb0, 0x90, 0x8f, 0x3f, 0x40, 0x14, 0xb9, 0x4c, 0x79, - 0x15, 0xa6, 0x51, 0xd3, 0xaf, 0x11, 0xea, 0xf8, 0xbb, 0x19, 0xb0, 0x08, 0x96, 0xd3, 0xc5, 0xcc, - 0x5f, 0x3f, 0x5f, 0x9c, 0x93, 0x1d, 0x6d, 0x58, 0x16, 0xc5, 0x8c, 0xdd, 0xf4, 0xa9, 0xe3, 0xd9, - 0x66, 0x1b, 0xaa, 0xbc, 0x01, 0xa7, 0x1b, 0xa2, 0x42, 0x66, 0x62, 0x11, 0x2c, 0x3f, 0xbd, 0x9e, - 0xd5, 0x63, 0x14, 0xd3, 0x83, 0x45, 0x8a, 0xe9, 0xfb, 0xfb, 0xf9, 0xd4, 0x8f, 0x47, 0x7b, 0x2b, - 0xc0, 0x94, 0x59, 0x05, 0xfd, 0xab, 0xa3, 0xbd, 0x95, 0x76, 0xbd, 0x6f, 0x8e, 0xf6, 0x56, 0xb2, - 0x36, 0x72, 0x50, 0x48, 0xa0, 0xa7, 0x4f, 0x6d, 0x1e, 0x9e, 0xef, 0x99, 0x32, 0x31, 0x6b, 0x10, - 0x8f, 0x61, 0xed, 0xcf, 0x09, 0x38, 0x5b, 0x62, 0xf6, 0x16, 0xd9, 0xc6, 0x9e, 0x73, 0x07, 0xdf, - 0xac, 0x21, 0x8a, 0x99, 0x72, 0x1d, 0xce, 0x5a, 0xb8, 0x8e, 0x6d, 0xe4, 0x13, 0x5a, 0x46, 0x01, - 0x0d, 0x49, 0x70, 0xe1, 0xd1, 0x7e, 0x3e, 0xb3, 0x8b, 0xdc, 0x7a, 0x41, 0xeb, 0x83, 0x68, 0xe6, - 0xe9, 0x68, 0x4e, 0x92, 0xe7, 0xa5, 0x76, 0x50, 0xdd, 0xb1, 0xba, 0x4a, 0x4d, 0xf4, 0x96, 0xea, - 0x83, 0x68, 0xe6, 0xe9, 0x68, 0x2e, 0x2c, 0x75, 0x19, 0x4e, 0x23, 0x97, 0x34, 0x3d, 0x3f, 0x33, - 0x29, 0x64, 0x9b, 0xd7, 0xa5, 0xd0, 0xdc, 0x40, 0x91, 0x6c, 0x6f, 0x13, 0xc7, 0x2b, 0x4e, 0x71, - 0xd1, 0x4c, 0x09, 0x57, 0xd6, 0xe1, 0x59, 0x5f, 0x12, 0xb4, 0xca, 0x8c, 0x53, 0x2c, 0x93, 0x96, - 0x87, 0x69, 0x66, 0x8a, 0xf7, 0x61, 0x9e, 0x89, 0x82, 0x82, 0xfe, 0xfb, 0x3c, 0x54, 0xb8, 0xf2, - 0xf5, 0xbd, 0x7c, 0xea, 0xdf, 0x7b, 0xf9, 0x14, 0xd7, 0xba, 0x5f, 0x0d, 0xae, 0xf9, 0x39, 0xa1, - 0x79, 0x9f, 0x7a, 0xda, 0x16, 0x9c, 0xef, 0x9b, 0x0c, 0x05, 0xef, 0x20, 0x01, 0xc6, 0x22, 0xa1, - 0x3d, 0x04, 0x30, 0x53, 0x62, 0xb6, 0x89, 0x2d, 0x8c, 0x5d, 0x51, 0x9c, 0xbd, 0x43, 0xe8, 0xff, - 0xbf, 0x61, 0xed, 0x06, 0x27, 0xc6, 0x6a, 0xb0, 0xf0, 0xd6, 0x70, 0xc5, 0x9e, 0x0d, 0x15, 0x8b, - 0x65, 0xa1, 0x7d, 0x06, 0x17, 0x93, 0x62, 0x4f, 0xae, 0xdf, 0xef, 0x00, 0xe6, 0xf8, 0xb6, 0x50, - 0xe4, 0xb1, 0x5b, 0x98, 0x76, 0x6d, 0x8f, 0x89, 0xab, 0x84, 0x5a, 0xca, 0x65, 0x98, 0x09, 0xad, - 0x20, 0x6d, 0x42, 0x45, 0xa0, 0xec, 0x58, 0x62, 0xb5, 0x29, 0x33, 0xf2, 0x51, 0x47, 0xda, 0x75, - 0x4b, 0x39, 0x07, 0xa7, 0x19, 0xf6, 0x2c, 0x4c, 0x03, 0x67, 0x9b, 0x72, 0xa4, 0x64, 0x61, 0xda, - 0xc3, 0x2d, 0x69, 0xb6, 0x49, 0x11, 0x9a, 0xf1, 0x70, 0x2b, 0x70, 0xd8, 0xd5, 0x4e, 0xbd, 0x64, - 0x06, 0x17, 0xe9, 0xf9, 0xc8, 0x56, 0xc9, 0xad, 0x6a, 0xcb, 0xf0, 0xc2, 0x60, 0x44, 0x74, 0xc2, - 0x7f, 0x08, 0x7c, 0x73, 0xcd, 0x61, 0xa8, 0x52, 0xc7, 0xc7, 0x76, 0xd0, 0xc7, 0xda, 0xfe, 0xd8, - 0x66, 0x34, 0x4d, 0x6c, 0x7f, 0x6c, 0x2c, 0x62, 0xf3, 0x3d, 0x10, 0x77, 0xd9, 0xa6, 0x77, 0xbc, - 0x64, 0xde, 0x1c, 0x4e, 0x66, 0x21, 0x24, 0x13, 0xd7, 0x8b, 0xd6, 0x80, 0xf9, 0x84, 0x50, 0xe4, - 0xe4, 0x12, 0x3c, 0x55, 0x25, 0x6e, 0xa3, 0x8e, 0x7d, 0x87, 0x78, 0x65, 0xfe, 0x22, 0x49, 0x4b, - 0xab, 0x7a, 0xf0, 0x5c, 0xe9, 0xe1, 0x73, 0xa5, 0x6f, 0x85, 0xcf, 0x55, 0x71, 0x86, 0x7b, 0xfa, - 0xee, 0x3f, 0x79, 0x60, 0x9e, 0x6c, 0x27, 0xf3, 0xb0, 0xf6, 0x07, 0x80, 0x4b, 0x25, 0x66, 0x7f, - 0xec, 0xf8, 0x35, 0x8b, 0xa2, 0x56, 0xac, 0x25, 0x5a, 0x88, 0x5a, 0xca, 0xeb, 0xf0, 0x19, 0x61, - 0xc8, 0x1e, 0x89, 0x32, 0x8f, 0xf6, 0xf3, 0x73, 0x81, 0x44, 0x5d, 0x61, 0xcd, 0x3c, 0x21, 0xc6, - 0xe1, 0xfd, 0x90, 0x85, 0xe9, 0xf6, 0xa9, 0x98, 0x10, 0xa7, 0x62, 0x86, 0xca, 0x83, 0x50, 0x78, - 0xb7, 0x53, 0xb7, 0xee, 0x65, 0xb8, 0x66, 0x2f, 0x86, 0x9a, 0x0d, 0xed, 0x52, 0xd3, 0xe1, 0xea, - 0x28, 0xb8, 0xc8, 0x18, 0xbf, 0x00, 0xf8, 0x42, 0x47, 0xc2, 0x46, 0xbd, 0x7e, 0x5c, 0x0a, 0x14, - 0x6e, 0x0c, 0x26, 0xb9, 0xda, 0x4b, 0x72, 0x50, 0x2f, 0xda, 0x1a, 0x1c, 0x15, 0x1a, 0x52, 0x5d, - 0xff, 0x75, 0x06, 0x4e, 0x96, 0x98, 0xad, 0x54, 0xe0, 0x89, 0xae, 0xaf, 0x23, 0x4b, 0xb1, 0x5f, - 0x23, 0x7a, 0x5e, 0x7e, 0x75, 0x75, 0x14, 0x54, 0x64, 0xd2, 0x1a, 0x3c, 0xd9, 0x73, 0xca, 0x2e, - 0x24, 0xe5, 0x77, 0xe3, 0x54, 0x7d, 0x34, 0x5c, 0xb4, 0xd2, 0x17, 0xf0, 0x6c, 0xfc, 0xdb, 0x76, - 0x31, 0xa9, 0x50, 0x2c, 0x5c, 0x7d, 0x65, 0x2c, 0x78, 0xb4, 0xfc, 0xb7, 0x00, 0x66, 0x07, 0xbd, - 0x0d, 0x97, 0x12, 0xe9, 0x24, 0x27, 0xa9, 0x57, 0x1f, 0x23, 0xa9, 0x53, 0x90, 0xf8, 0x4b, 0x3b, - 0x51, 0x90, 0x58, 0x78, 0xb2, 0x20, 0x03, 0x6f, 0x5a, 0xe5, 0x0e, 0x9c, 0x8b, 0xbd, 0x65, 0x13, - 0xfd, 0x13, 0x87, 0x56, 0x5f, 0x1e, 0x07, 0x1d, 0xad, 0xfd, 0x1d, 0x80, 0xcf, 0x0d, 0xbf, 0xc8, - 0xae, 0x24, 0xd5, 0x1e, 0x9a, 0xaa, 0x6e, 0x3c, 0x76, 0x6a, 0xd4, 0xe3, 0x4f, 0x00, 0x2e, 0x8d, - 0x74, 0xdb, 0xbc, 0x36, 0x6c, 0xad, 0x41, 0xd9, 0xea, 0xb5, 0x27, 0xc9, 0x0e, 0x9b, 0x55, 0x9f, - 0xfa, 0x92, 0xff, 0x80, 0x28, 0x6e, 0xde, 0x3f, 0xc8, 0x81, 0x07, 0x07, 0x39, 0xf0, 0xf0, 0x20, - 0x07, 0xee, 0x1e, 0xe6, 0x52, 0x0f, 0x0e, 0x73, 0xa9, 0xbf, 0x0f, 0x73, 0xa9, 0x4f, 0x5f, 0xb2, - 0x1d, 0xbf, 0xd6, 0xac, 0xe8, 0x55, 0xe2, 0x1a, 0x37, 0x3e, 0xf9, 0x68, 0xf3, 0x3d, 0xec, 0xb7, - 0x08, 0xdd, 0x36, 0xaa, 0x35, 0xe4, 0x78, 0xc6, 0xed, 0xf0, 0x97, 0x85, 0xbf, 0xdb, 0xc0, 0xac, - 0x32, 0x2d, 0x1e, 0xa6, 0x4b, 0xff, 0x05, 0x00, 0x00, 0xff, 0xff, 0x18, 0xac, 0xf5, 0x07, 0x07, + 0x35, 0xc3, 0xbf, 0xad, 0x37, 0x28, 0xf1, 0x89, 0x72, 0x86, 0xa3, 0x7a, 0x80, 0xea, 0x12, 0x55, + 0x67, 0x91, 0xeb, 0x78, 0xc4, 0x10, 0x7f, 0x03, 0x9e, 0x9a, 0xab, 0x12, 0xe6, 0x12, 0x66, 0x54, + 0x10, 0xc3, 0x51, 0x96, 0x2a, 0x71, 0x3c, 0x89, 0x9f, 0x97, 0xb8, 0xcb, 0x6c, 0x63, 0x67, 0x8d, + 0xff, 0x93, 0xc0, 0x7c, 0x00, 0x94, 0xc5, 0xc8, 0x08, 0x06, 0x12, 0x9a, 0xb3, 0x89, 0x4d, 0x82, + 0x79, 0xfe, 0x49, 0xce, 0xe6, 0x6d, 0x42, 0xec, 0x3a, 0x36, 0xc4, 0xa8, 0xd2, 0xbc, 0x65, 0xf8, + 0x8e, 0x8b, 0x99, 0x8f, 0xdc, 0x86, 0x24, 0x2c, 0xc6, 0x09, 0x92, 0x0a, 0x04, 0x43, 0xfb, 0x0d, + 0xc0, 0x53, 0x25, 0x66, 0x7f, 0xd8, 0xb0, 0x90, 0x8f, 0x3f, 0x40, 0x14, 0xb9, 0x4c, 0x79, 0x15, + 0xa6, 0x51, 0xd3, 0xaf, 0x11, 0xea, 0xf8, 0xbb, 0x19, 0xb0, 0x08, 0x96, 0xd3, 0xc5, 0xcc, 0x5f, + 0x3f, 0x5f, 0x9c, 0x93, 0x15, 0x6d, 0x58, 0x16, 0xc5, 0x8c, 0xdd, 0xf4, 0xa9, 0xe3, 0xd9, 0x66, + 0x9b, 0xaa, 0xbc, 0x01, 0xa7, 0x1b, 0x22, 0x43, 0x66, 0x62, 0x11, 0x2c, 0x3f, 0xbd, 0x9e, 0xd5, + 0x63, 0x1c, 0xd3, 0x83, 0x45, 0x8a, 0xe9, 0xfb, 0xfb, 0xf9, 0xd4, 0x8f, 0x47, 0x7b, 0x2b, 0xc0, + 0x94, 0x51, 0x05, 0xfd, 0xab, 0xa3, 0xbd, 0x95, 0x76, 0xbe, 0x6f, 0x8e, 0xf6, 0x56, 0xb2, 0x36, + 0x72, 0x50, 0x28, 0xa0, 0xa7, 0x4e, 0x6d, 0x1e, 0x9e, 0xef, 0x99, 0x32, 0x31, 0x6b, 0x10, 0x8f, + 0x61, 0xed, 0xcf, 0x09, 0x38, 0x5b, 0x62, 0xf6, 0x16, 0xd9, 0xc6, 0x9e, 0x73, 0x07, 0xdf, 0xac, + 0x21, 0x8a, 0x99, 0x72, 0x1d, 0xce, 0x5a, 0xb8, 0x8e, 0x6d, 0xe4, 0x13, 0x5a, 0x46, 0x81, 0x0c, + 0x29, 0x70, 0xe1, 0xd1, 0x7e, 0x3e, 0xb3, 0x8b, 0xdc, 0x7a, 0x41, 0xeb, 0xa3, 0x68, 0xe6, 0xe9, + 0x68, 0x4e, 0x8a, 0xe7, 0xa9, 0x76, 0x50, 0xdd, 0xb1, 0xba, 0x52, 0x4d, 0xf4, 0xa6, 0xea, 0xa3, + 0x68, 0xe6, 0xe9, 0x68, 0x2e, 0x4c, 0x75, 0x19, 0x4e, 0x23, 0x97, 0x34, 0x3d, 0x3f, 0x33, 0x29, + 0x6c, 0x9b, 0xd7, 0xa5, 0xd1, 0xbc, 0x81, 0x22, 0xdb, 0xde, 0x26, 0x8e, 0x57, 0x9c, 0xe2, 0xa6, + 0x99, 0x92, 0xae, 0xac, 0xc3, 0xb3, 0xbe, 0x14, 0x68, 0x95, 0x19, 0x97, 0x58, 0x26, 0x2d, 0x0f, + 0xd3, 0xcc, 0x14, 0xaf, 0xc3, 0x3c, 0x13, 0x81, 0x42, 0xfe, 0xfb, 0x1c, 0x2a, 0x5c, 0xf9, 0xfa, + 0x5e, 0x3e, 0xf5, 0xef, 0xbd, 0x7c, 0x8a, 0x7b, 0xdd, 0xef, 0x06, 0xf7, 0xfc, 0x9c, 0xf0, 0xbc, + 0xcf, 0x3d, 0x6d, 0x0b, 0xce, 0xf7, 0x4d, 0x86, 0x86, 0x77, 0x88, 0x00, 0x63, 0x89, 0xd0, 0x1e, + 0x02, 0x98, 0x29, 0x31, 0xdb, 0xc4, 0x16, 0xc6, 0xae, 0x48, 0xce, 0xde, 0x21, 0xf4, 0xff, 0xdf, + 0xb0, 0x76, 0x81, 0x13, 0x63, 0x15, 0x58, 0x78, 0x6b, 0xb8, 0x63, 0xcf, 0x8a, 0x63, 0x96, 0xa4, + 0x42, 0xfb, 0x0c, 0x2e, 0x26, 0x61, 0x4f, 0xee, 0xdf, 0xef, 0x00, 0xe6, 0xf8, 0xb6, 0x50, 0xe4, + 0xb1, 0x5b, 0x98, 0x76, 0x6d, 0x8f, 0x89, 0xab, 0x84, 0x5a, 0xca, 0x65, 0x98, 0x09, 0x5b, 0x41, + 0xb6, 0x09, 0x15, 0x40, 0xd9, 0xb1, 0xc4, 0x6a, 0x53, 0x66, 0xd4, 0x47, 0x1d, 0x61, 0xd7, 0x2d, + 0xe5, 0x1c, 0x9c, 0x66, 0xd8, 0xb3, 0x30, 0x0d, 0x3a, 0xdb, 0x94, 0x23, 0x25, 0x0b, 0xd3, 0x1e, + 0x6e, 0xc9, 0x66, 0x9b, 0x14, 0xd0, 0x8c, 0x87, 0x5b, 0x41, 0x87, 0x5d, 0xed, 0xf4, 0x4b, 0x46, + 0x70, 0x93, 0x9e, 0x0f, 0x4d, 0x1a, 0x50, 0xaa, 0xb6, 0x0c, 0x2f, 0x0c, 0x66, 0x44, 0x27, 0xfc, + 0x87, 0xa0, 0x6f, 0xae, 0x39, 0x0c, 0x55, 0xea, 0xf8, 0xd8, 0x0e, 0xfa, 0x58, 0xdb, 0x1f, 0x5b, + 0x8c, 0xa6, 0x89, 0xed, 0x8f, 0xc5, 0x22, 0x35, 0xdf, 0x03, 0x71, 0x97, 0x6d, 0x7a, 0xc7, 0x2b, + 0xe6, 0xcd, 0xe1, 0x62, 0x16, 0x42, 0x31, 0x71, 0xb5, 0x68, 0x0d, 0x98, 0x4f, 0x80, 0xa2, 0x4e, + 0x2e, 0xc1, 0x53, 0x55, 0xe2, 0x36, 0xea, 0xd8, 0x77, 0x88, 0x57, 0xe6, 0x2f, 0x92, 0x6c, 0x69, + 0x55, 0x0f, 0x9e, 0x2b, 0x3d, 0x7c, 0xae, 0xf4, 0xad, 0xf0, 0xb9, 0x2a, 0xce, 0xf0, 0x9e, 0xbe, + 0xfb, 0x4f, 0x1e, 0x98, 0x27, 0xdb, 0xc1, 0x1c, 0xd6, 0xfe, 0x00, 0x70, 0xa9, 0xc4, 0xec, 0x8f, + 0x1d, 0xbf, 0x66, 0x51, 0xd4, 0x8a, 0x6d, 0x89, 0x16, 0xa2, 0x96, 0xf2, 0x3a, 0x7c, 0x46, 0x34, + 0x64, 0x8f, 0x45, 0x99, 0x47, 0xfb, 0xf9, 0xb9, 0xc0, 0xa2, 0x2e, 0x58, 0x33, 0x4f, 0x88, 0x71, + 0x78, 0x3f, 0x64, 0x61, 0xba, 0x7d, 0x2a, 0x26, 0xc4, 0xa9, 0x98, 0xa1, 0xf2, 0x20, 0x14, 0xde, + 0xed, 0xf4, 0xad, 0x7b, 0x19, 0xee, 0xd9, 0x8b, 0xa1, 0x67, 0x43, 0xab, 0xd4, 0x74, 0xb8, 0x3a, + 0x0a, 0x2f, 0x6a, 0x8c, 0x5f, 0x00, 0x7c, 0xa1, 0x23, 0x60, 0xa3, 0x5e, 0x3f, 0x2e, 0x07, 0x0a, + 0x37, 0x06, 0x8b, 0x5c, 0xed, 0x15, 0x39, 0xa8, 0x16, 0x6d, 0x0d, 0x8e, 0x4a, 0x0d, 0xa5, 0xae, + 0xff, 0x3a, 0x03, 0x27, 0x4b, 0xcc, 0x56, 0x2a, 0xf0, 0x44, 0xd7, 0xd7, 0x91, 0xa5, 0xd8, 0xaf, + 0x11, 0x3d, 0x2f, 0xbf, 0xba, 0x3a, 0x0a, 0x2b, 0x6a, 0xd2, 0x1a, 0x3c, 0xd9, 0x73, 0xca, 0x2e, + 0x24, 0xc5, 0x77, 0xf3, 0x54, 0x7d, 0x34, 0x5e, 0xb4, 0xd2, 0x17, 0xf0, 0x6c, 0xfc, 0xdb, 0x76, + 0x31, 0x29, 0x51, 0x2c, 0x5d, 0x7d, 0x65, 0x2c, 0x7a, 0xb4, 0xfc, 0xb7, 0x00, 0x66, 0x07, 0xbd, + 0x0d, 0x97, 0x12, 0xe5, 0x24, 0x07, 0xa9, 0x57, 0x1f, 0x23, 0xa8, 0xd3, 0x90, 0xf8, 0x4b, 0x3b, + 0xd1, 0x90, 0x58, 0x7a, 0xb2, 0x21, 0x03, 0x6f, 0x5a, 0xe5, 0x0e, 0x9c, 0x8b, 0xbd, 0x65, 0x13, + 0xfb, 0x27, 0x8e, 0xad, 0xbe, 0x3c, 0x0e, 0x3b, 0x5a, 0xfb, 0x3b, 0x00, 0x9f, 0x1b, 0x7e, 0x91, + 0x5d, 0x49, 0xca, 0x3d, 0x34, 0x54, 0xdd, 0x78, 0xec, 0xd0, 0xa8, 0xc6, 0x9f, 0x00, 0x5c, 0x1a, + 0xe9, 0xb6, 0x79, 0x6d, 0xd8, 0x5a, 0x83, 0xa2, 0xd5, 0x6b, 0x4f, 0x12, 0x1d, 0x16, 0xab, 0x3e, + 0xf5, 0x25, 0xff, 0x01, 0x51, 0xdc, 0xbc, 0x7f, 0x90, 0x03, 0x0f, 0x0e, 0x72, 0xe0, 0xe1, 0x41, + 0x0e, 0xdc, 0x3d, 0xcc, 0xa5, 0x1e, 0x1c, 0xe6, 0x52, 0x7f, 0x1f, 0xe6, 0x52, 0x9f, 0xbe, 0x64, + 0x3b, 0x7e, 0xad, 0x59, 0xd1, 0xab, 0xc4, 0x35, 0x6e, 0x7c, 0xf2, 0xd1, 0xe6, 0x7b, 0xd8, 0x6f, + 0x11, 0xba, 0x6d, 0x54, 0x6b, 0xc8, 0xf1, 0x8c, 0xdb, 0xe1, 0x2f, 0x0b, 0x7f, 0xb7, 0x81, 0x59, + 0x65, 0x5a, 0x3c, 0x4c, 0x97, 0xfe, 0x0b, 0x00, 0x00, 0xff, 0xff, 0x3e, 0x10, 0x0f, 0xdd, 0x07, 0x0e, 0x00, 0x00, } From 636b83ee073af8219d1b151f0534ab407ea6ec3c Mon Sep 17 00:00:00 2001 From: mbreithecker Date: Wed, 27 Aug 2025 10:29:26 +0200 Subject: [PATCH 8/8] chore: resolve comments and set params in update migration --- app/upgrades/v2_2/upgrade.go | 15 +++- docs/static/openapi.yml | 4 +- proto/kyve/liquid/v1beta1/liquid.proto | 2 +- proto/kyve/liquid/v1beta1/query.proto | 4 +- proto/kyve/liquid/v1beta1/tx.proto | 4 +- x/liquid/client/cli/tx.go | 5 +- x/liquid/types/liquid.pb.go | 60 ++++++------- x/liquid/types/query.pb.go | 4 +- x/liquid/types/tx.pb.go | 120 ++++++++++++------------- 9 files changed, 115 insertions(+), 103 deletions(-) diff --git a/app/upgrades/v2_2/upgrade.go b/app/upgrades/v2_2/upgrade.go index f55fd469..60e027b1 100644 --- a/app/upgrades/v2_2/upgrade.go +++ b/app/upgrades/v2_2/upgrade.go @@ -4,7 +4,9 @@ import ( "context" "fmt" + "cosmossdk.io/math" liquidkeeper "github.com/KYVENetwork/chain/x/liquid/keeper" + liquidtypes "github.com/KYVENetwork/chain/x/liquid/types" stakingKeeper "github.com/cosmos/cosmos-sdk/x/staking/keeper" "cosmossdk.io/log" @@ -33,9 +35,12 @@ func CreateUpgradeHandler( // Run cosmos migrations migratedVersionMap, err := mm.RunMigrations(ctx, configurator, fromVM) + if err != nil { + return nil, err + } // Run KYVE migrations - validators, _ := stakingKeeper.GetValidators(ctx, 1_000) + validators, _ := stakingKeeper.GetAllValidators(ctx) for _, v := range validators { valAddress, _ := sdk.ValAddressFromBech32(v.OperatorAddress) err := liquidStakingKeeper.Hooks().AfterValidatorCreated(ctx, valAddress) @@ -44,6 +49,14 @@ func CreateUpgradeHandler( } } + err = liquidStakingKeeper.SetParams(ctx, liquidtypes.Params{ + GlobalLiquidStakingCap: math.LegacyMustNewDecFromStr("0.25"), + ValidatorLiquidStakingCap: math.LegacyMustNewDecFromStr("0.25"), + }) + if err != nil { + return nil, err + } + logger.Info(fmt.Sprintf("finished upgrade %v", UpgradeName)) return migratedVersionMap, err diff --git a/docs/static/openapi.yml b/docs/static/openapi.yml index edd67f26..8bb22cf0 100644 --- a/docs/static/openapi.yml +++ b/docs/static/openapi.yml @@ -9831,7 +9831,7 @@ paths: title: validator delegated to for tokenize share record creation title: TokenizeShareRecord represents a tokenized delegation description: |- - QueryTokenizeShareRecordByIdRequest is response type for the + QueryTokenizeShareRecordByIdResponse is response type for the Query/QueryTokenizeShareRecordById RPC method. default: description: An unexpected error response. @@ -10060,7 +10060,7 @@ paths: type: string description: |- QueryTotalLiquidStakedResponse is response type for the - Query/QueryQueryTotalLiquidStaked RPC method. + Query/QueryTotalLiquidStaked RPC method. default: description: An unexpected error response. schema: diff --git a/proto/kyve/liquid/v1beta1/liquid.proto b/proto/kyve/liquid/v1beta1/liquid.proto index beb49ab2..ef08cf89 100644 --- a/proto/kyve/liquid/v1beta1/liquid.proto +++ b/proto/kyve/liquid/v1beta1/liquid.proto @@ -14,7 +14,7 @@ option go_package = "github.com/KYVENetwork/chain/x/liquid/types"; // Params defines the parameters for the x/liquid module. message Params { - option (amino.name) = "gaia/x/liquid/Params"; + option (amino.name) = "kyve/x/liquid/Params"; option (gogoproto.equal) = true; // global_liquid_staking_cap represents a cap on the portion of stake that diff --git a/proto/kyve/liquid/v1beta1/query.proto b/proto/kyve/liquid/v1beta1/query.proto index f758c9ac..282ea1a4 100644 --- a/proto/kyve/liquid/v1beta1/query.proto +++ b/proto/kyve/liquid/v1beta1/query.proto @@ -135,7 +135,7 @@ message QueryTokenizeShareRecordByIdRequest { uint64 id = 1; } -// QueryTokenizeShareRecordByIdRequest is response type for the +// QueryTokenizeShareRecordByIdResponse is response type for the // Query/QueryTokenizeShareRecordById RPC method. message QueryTokenizeShareRecordByIdResponse { TokenizeShareRecord record = 1 [(gogoproto.nullable) = false]; @@ -205,7 +205,7 @@ message QueryTotalTokenizeSharedAssetsResponse { message QueryTotalLiquidStaked {} // QueryTotalLiquidStakedResponse is response type for the -// Query/QueryQueryTotalLiquidStaked RPC method. +// Query/QueryTotalLiquidStaked RPC method. message QueryTotalLiquidStakedResponse { string tokens = 1; } diff --git a/proto/kyve/liquid/v1beta1/tx.proto b/proto/kyve/liquid/v1beta1/tx.proto index 2a57e14e..f57ad84d 100644 --- a/proto/kyve/liquid/v1beta1/tx.proto +++ b/proto/kyve/liquid/v1beta1/tx.proto @@ -54,7 +54,7 @@ service Msg { // MsgUpdateParams is the Msg/UpdateParams request type. message MsgUpdateParams { option (cosmos.msg.v1.signer) = "authority"; - option (amino.name) = "gaia/liquid/MsgUpdateParams"; + option (amino.name) = "kyve/liquid/MsgUpdateParams"; // authority is the address that controls the module (defaults to x/gov unless // overwritten). @@ -75,7 +75,7 @@ message MsgUpdateParamsResponse {} // MsgTokenizeShares tokenizes a delegation message MsgTokenizeShares { option (cosmos.msg.v1.signer) = "delegator_address"; - option (amino.name) = "gaia/MsgTokenizeShares"; + option (amino.name) = "kyve/MsgTokenizeShares"; option (gogoproto.equal) = false; option (gogoproto.goproto_getters) = false; diff --git a/x/liquid/client/cli/tx.go b/x/liquid/client/cli/tx.go index 99bd72db..cc4ea8de 100644 --- a/x/liquid/client/cli/tx.go +++ b/x/liquid/client/cli/tx.go @@ -1,7 +1,6 @@ // This file was modified from its original version. // Original source: https://github.com/cosmos/gaia/blob/b3583a755ad2947582f8e9c969806b187668ea23/x/liquid/client/cli/tx.go // Modifications made by KYVE, 2025. -// - Changed import paths package cli @@ -274,7 +273,7 @@ func NewWithdrawAllTokenizeShareRecordRewardCmd(ac address.Codec) *cobra.Command Long: strings.TrimSpace( fmt.Sprintf(`Withdraw reward for all owned TokenizeShareRecord Example: -$ %s tx distribution withdraw-all-tokenize-share-rewards --from mykey +$ %s tx liquid withdraw-all-tokenize-share-rewards --from mykey `, version.AppName, ), @@ -310,7 +309,7 @@ func NewWithdrawTokenizeShareRecordRewardCmd(ac address.Codec) *cobra.Command { Long: strings.TrimSpace( fmt.Sprintf(`Withdraw reward for an owned TokenizeShareRecord Example: -$ %s tx distribution withdraw-tokenize-share-rewards 1 --from mykey +$ %s tx liquid withdraw-tokenize-share-rewards 1 --from mykey `, version.AppName, ), diff --git a/x/liquid/types/liquid.pb.go b/x/liquid/types/liquid.pb.go index 1582b800..dc963567 100644 --- a/x/liquid/types/liquid.pb.go +++ b/x/liquid/types/liquid.pb.go @@ -318,7 +318,7 @@ func init() { func init() { proto.RegisterFile("kyve/liquid/v1beta1/liquid.proto", fileDescriptor_83fe2aa3458e6a34) } var fileDescriptor_83fe2aa3458e6a34 = []byte{ - // 761 bytes of a gzipped FileDescriptorProto + // 760 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x54, 0x4d, 0x4f, 0xe3, 0x46, 0x18, 0xce, 0x24, 0x29, 0x22, 0xd3, 0x02, 0xa9, 0x89, 0x5a, 0x07, 0xa8, 0x93, 0x1a, 0xd1, 0x46, 0x69, 0x89, 0x45, 0xb9, 0xa5, 0xa7, 0x7c, 0xb8, 0x6d, 0x44, 0x14, 0x22, 0x3b, 0xa0, 0x16, 0xa9, @@ -338,35 +338,35 @@ var fileDescriptor_83fe2aa3458e6a34 = []byte{ 0xdd, 0x55, 0xb1, 0xf9, 0xe8, 0xfa, 0x28, 0x0f, 0xb4, 0xcf, 0x38, 0xbd, 0x1e, 0xb0, 0x75, 0x4e, 0xae, 0xa0, 0x81, 0xf0, 0x1f, 0x80, 0x4b, 0xbb, 0xa8, 0x47, 0x2c, 0xe4, 0x51, 0xf7, 0x2e, 0x6b, 0x89, 0xc0, 0xda, 0xaf, 0x0f, 0xb3, 0xb6, 0xcc, 0xad, 0xdd, 0x27, 0x78, 0xa7, 0xbb, 0xf4, 0xe4, - 0xc6, 0xbb, 0x06, 0x8b, 0x5f, 0xbc, 0x3a, 0xcc, 0x80, 0xbf, 0xae, 0x8f, 0xf2, 0x29, 0x1b, 0x11, - 0xa4, 0xfc, 0x31, 0x9e, 0x34, 0xef, 0xab, 0xfc, 0x27, 0x80, 0xf3, 0x2d, 0xda, 0xc5, 0x0e, 0xd9, - 0xc7, 0x7a, 0x07, 0xb9, 0x58, 0xc3, 0x26, 0x75, 0x2d, 0x61, 0x16, 0x46, 0x89, 0x25, 0x82, 0x2c, - 0xc8, 0xc5, 0xb5, 0x28, 0xb1, 0x84, 0x14, 0xfc, 0x88, 0xee, 0x39, 0xd8, 0x15, 0xa3, 0x7e, 0x3d, - 0x1a, 0x0f, 0x84, 0x15, 0x38, 0xdb, 0xa7, 0xd6, 0xb0, 0x87, 0x0d, 0x64, 0x9a, 0x74, 0xe8, 0x78, - 0x62, 0x2c, 0x48, 0xcf, 0x70, 0xb4, 0xc4, 0x41, 0x61, 0x09, 0x26, 0x26, 0x06, 0xc5, 0x78, 0xc0, - 0xb8, 0x01, 0x8a, 0x71, 0xdf, 0xa1, 0x5c, 0x86, 0x72, 0x13, 0x3b, 0x16, 0x71, 0xec, 0x5b, 0x76, - 0x4a, 0x43, 0xaf, 0x43, 0x5d, 0xb2, 0x8f, 0x3c, 0x42, 0x1d, 0xe6, 0x2b, 0x21, 0xcb, 0x72, 0x31, - 0x63, 0x98, 0x89, 0x20, 0x1b, 0xf3, 0x95, 0x26, 0x80, 0xfc, 0x04, 0xc0, 0xf4, 0x1d, 0xc5, 0x68, - 0x78, 0x0f, 0xb9, 0x96, 0xb0, 0x08, 0x13, 0x6e, 0x10, 0x1b, 0x93, 0xca, 0xa6, 0x39, 0x50, 0xb3, - 0x04, 0x02, 0xa7, 0xdc, 0x80, 0x26, 0x46, 0xb3, 0xb1, 0xdc, 0xc7, 0xdf, 0x2d, 0x15, 0xc2, 0x1e, - 0xfb, 0xcb, 0x3c, 0x5e, 0x7a, 0xbf, 0xe1, 0x15, 0x4a, 0x9c, 0xf2, 0xba, 0x3f, 0xce, 0xc7, 0x2f, - 0x33, 0xdf, 0xd8, 0xc4, 0xeb, 0x0c, 0xdb, 0x05, 0x93, 0xf6, 0xc3, 0x7d, 0x0e, 0xff, 0x56, 0x99, - 0xd5, 0x55, 0xbc, 0xd1, 0x00, 0xb3, 0xf1, 0x1d, 0xa6, 0x85, 0x0f, 0x28, 0x4e, 0x1f, 0x1c, 0x66, - 0x22, 0xff, 0xfa, 0x35, 0x3f, 0x05, 0x70, 0x8e, 0x0f, 0x6c, 0x7b, 0xdc, 0x0d, 0xa1, 0x02, 0x93, - 0x74, 0x80, 0xdd, 0x60, 0xfa, 0x61, 0x65, 0x81, 0xd9, 0x44, 0x59, 0x3c, 0x3b, 0x5e, 0x4d, 0x85, - 0xae, 0x4a, 0x3c, 0xa3, 0x7b, 0x2e, 0x71, 0x6c, 0x6d, 0x6e, 0x7c, 0x23, 0x84, 0x85, 0xdf, 0xe0, - 0xcc, 0x78, 0x73, 0xfc, 0x36, 0x30, 0x3e, 0x96, 0xf2, 0xf7, 0x0f, 0xdb, 0xc2, 0x14, 0xdf, 0xc2, - 0x5b, 0x0a, 0xb2, 0xf6, 0x09, 0x8f, 0x83, 0xbe, 0xb2, 0x9b, 0x22, 0xf2, 0xcf, 0x00, 0xfc, 0xfc, - 0x56, 0xd3, 0xeb, 0xd4, 0xec, 0xea, 0x1e, 0xf2, 0x86, 0x4c, 0xc8, 0xc3, 0xaf, 0x5a, 0x9b, 0x1b, - 0x6a, 0xa3, 0xb6, 0xa3, 0x1a, 0xfa, 0x4f, 0x25, 0x4d, 0x35, 0xea, 0x9b, 0x95, 0x0d, 0x43, 0x6f, - 0x95, 0x5a, 0x5b, 0xba, 0xb1, 0xd5, 0xd0, 0x9b, 0x6a, 0xa5, 0xf6, 0x43, 0x4d, 0xad, 0x26, 0x23, - 0xc2, 0x0a, 0xfc, 0xf2, 0x1e, 0xae, 0x7f, 0x56, 0xab, 0x49, 0x20, 0x7c, 0x0d, 0x97, 0xef, 0x95, - 0x0c, 0x89, 0x51, 0xe1, 0x5b, 0x98, 0xfb, 0x80, 0x9e, 0xa1, 0xfe, 0xdc, 0xac, 0x69, 0xb5, 0xc6, - 0x8f, 0xc9, 0xd8, 0x42, 0xfc, 0xe0, 0x7f, 0x29, 0x52, 0x56, 0x4f, 0x2e, 0x25, 0x70, 0x7a, 0x29, - 0x81, 0x8b, 0x4b, 0x09, 0xfc, 0x7d, 0x25, 0x45, 0x4e, 0xaf, 0xa4, 0xc8, 0xf3, 0x2b, 0x29, 0xb2, - 0xf3, 0xf6, 0xa4, 0x37, 0x7e, 0xd9, 0x56, 0x1b, 0xd8, 0xdb, 0xa3, 0x6e, 0x57, 0x31, 0x3b, 0x88, - 0x38, 0x37, 0x6f, 0x55, 0x30, 0xf2, 0xf6, 0x54, 0xf0, 0xf9, 0x5a, 0x7f, 0x13, 0x00, 0x00, 0xff, - 0xff, 0x97, 0x6f, 0x0f, 0x8e, 0x5b, 0x05, 0x00, 0x00, + 0xc6, 0xbb, 0x06, 0x8b, 0x5f, 0xbc, 0x3a, 0xcc, 0x80, 0xbf, 0xae, 0x8f, 0xf2, 0xa9, 0x60, 0xce, + 0x7f, 0x8c, 0x27, 0xcd, 0xfb, 0x2a, 0xff, 0x09, 0xe0, 0x7c, 0x8b, 0x76, 0xb1, 0x43, 0xf6, 0xb1, + 0xde, 0x41, 0x2e, 0xd6, 0xb0, 0x49, 0x5d, 0x4b, 0x98, 0x85, 0x51, 0x62, 0x89, 0x20, 0x0b, 0x72, + 0x71, 0x2d, 0x4a, 0x2c, 0x21, 0x05, 0x3f, 0xa2, 0x7b, 0x0e, 0x76, 0xc5, 0xa8, 0x5f, 0x8f, 0xc6, + 0x03, 0x61, 0x05, 0xce, 0xf6, 0xa9, 0x35, 0xec, 0x61, 0x03, 0x99, 0x26, 0x1d, 0x3a, 0x9e, 0x18, + 0x0b, 0xd2, 0x33, 0x1c, 0x2d, 0x71, 0x50, 0x58, 0x82, 0x89, 0x89, 0x41, 0x31, 0x1e, 0x30, 0x6e, + 0x80, 0x62, 0xdc, 0x77, 0x28, 0x97, 0xa1, 0xdc, 0xc4, 0x8e, 0x45, 0x1c, 0xfb, 0x96, 0x9d, 0xd2, + 0xd0, 0xeb, 0x50, 0x97, 0xec, 0x23, 0x8f, 0x50, 0x87, 0xf9, 0x4a, 0xc8, 0xb2, 0x5c, 0xcc, 0x18, + 0x66, 0x22, 0xc8, 0xc6, 0x7c, 0xa5, 0x09, 0x20, 0x3f, 0x01, 0x30, 0x7d, 0x47, 0x31, 0x1a, 0xde, + 0x43, 0xae, 0x25, 0x2c, 0xc2, 0x84, 0x1b, 0xc4, 0xc6, 0xa4, 0xb2, 0x69, 0x0e, 0xd4, 0x2c, 0x81, + 0xc0, 0x29, 0x37, 0xa0, 0x89, 0xd1, 0x6c, 0x2c, 0xf7, 0xf1, 0x77, 0x4b, 0x85, 0xb0, 0xc7, 0xfe, + 0x32, 0x8f, 0x97, 0xde, 0x6f, 0x78, 0x85, 0x12, 0xa7, 0xbc, 0xee, 0x8f, 0xf3, 0xf1, 0xcb, 0xcc, + 0x37, 0x36, 0xf1, 0x3a, 0xc3, 0x76, 0xc1, 0xa4, 0xfd, 0x70, 0x9f, 0xc3, 0xbf, 0x55, 0x66, 0x75, + 0x15, 0x6f, 0x34, 0xc0, 0x6c, 0x7c, 0x87, 0x69, 0xe1, 0x03, 0x8a, 0xd3, 0x07, 0x87, 0x99, 0xc8, + 0xbf, 0x7e, 0xcd, 0x4f, 0x01, 0x9c, 0xe3, 0x03, 0xdb, 0x1e, 0x77, 0x43, 0xa8, 0xc0, 0x24, 0x1d, + 0x60, 0x37, 0x98, 0x7e, 0x58, 0x59, 0x60, 0x36, 0x51, 0x16, 0xcf, 0x8e, 0x57, 0x53, 0xa1, 0xab, + 0x12, 0xcf, 0xe8, 0x9e, 0x4b, 0x1c, 0x5b, 0x9b, 0x1b, 0xdf, 0x08, 0x61, 0xe1, 0x37, 0x38, 0x33, + 0xde, 0x1c, 0xbf, 0x0d, 0x8c, 0x8f, 0xa5, 0xfc, 0xfd, 0xc3, 0xb6, 0x30, 0xc5, 0xb7, 0xf0, 0x96, + 0x82, 0xac, 0x7d, 0xc2, 0xe3, 0xa0, 0xaf, 0xec, 0xa6, 0x88, 0xfc, 0x33, 0x00, 0x3f, 0xbf, 0xd5, + 0xf4, 0x3a, 0x35, 0xbb, 0xba, 0x87, 0xbc, 0x21, 0x13, 0xf2, 0xf0, 0xab, 0xd6, 0xe6, 0x86, 0xda, + 0xa8, 0xed, 0xa8, 0x86, 0xfe, 0x53, 0x49, 0x53, 0x8d, 0xfa, 0x66, 0x65, 0xc3, 0xd0, 0x5b, 0xa5, + 0xd6, 0x96, 0x6e, 0x6c, 0x35, 0xf4, 0xa6, 0x5a, 0xa9, 0xfd, 0x50, 0x53, 0xab, 0xc9, 0x88, 0xb0, + 0x02, 0xbf, 0xbc, 0x87, 0xeb, 0x9f, 0xd5, 0x6a, 0x12, 0x08, 0x5f, 0xc3, 0xe5, 0x7b, 0x25, 0x43, + 0x62, 0x54, 0xf8, 0x16, 0xe6, 0x3e, 0xa0, 0x67, 0xa8, 0x3f, 0x37, 0x6b, 0x5a, 0xad, 0xf1, 0x63, + 0x32, 0xb6, 0x10, 0x3f, 0xf8, 0x5f, 0x8a, 0x94, 0xd5, 0x93, 0x4b, 0x09, 0x9c, 0x5e, 0x4a, 0xe0, + 0xe2, 0x52, 0x02, 0x7f, 0x5f, 0x49, 0x91, 0xd3, 0x2b, 0x29, 0xf2, 0xfc, 0x4a, 0x8a, 0xec, 0xbc, + 0x3d, 0xe9, 0x8d, 0x5f, 0xb6, 0xd5, 0x06, 0xf6, 0xf6, 0xa8, 0xdb, 0x55, 0xcc, 0x0e, 0x22, 0xce, + 0xcd, 0x5b, 0x15, 0x8c, 0xbc, 0x3d, 0x15, 0x7c, 0xbe, 0xd6, 0xdf, 0x04, 0x00, 0x00, 0xff, 0xff, + 0xe3, 0x7f, 0x65, 0xb5, 0x5b, 0x05, 0x00, 0x00, } func (this *Params) Equal(that interface{}) bool { diff --git a/x/liquid/types/query.pb.go b/x/liquid/types/query.pb.go index 4acd3957..367650b6 100644 --- a/x/liquid/types/query.pb.go +++ b/x/liquid/types/query.pb.go @@ -356,7 +356,7 @@ func (m *QueryTokenizeShareRecordByIdRequest) GetId() uint64 { return 0 } -// QueryTokenizeShareRecordByIdRequest is response type for the +// QueryTokenizeShareRecordByIdResponse is response type for the // Query/QueryTokenizeShareRecordById RPC method. type QueryTokenizeShareRecordByIdResponse struct { Record TokenizeShareRecord `protobuf:"bytes,1,opt,name=record,proto3" json:"record"` @@ -905,7 +905,7 @@ func (m *QueryTotalLiquidStaked) XXX_DiscardUnknown() { var xxx_messageInfo_QueryTotalLiquidStaked proto.InternalMessageInfo // QueryTotalLiquidStakedResponse is response type for the -// Query/QueryQueryTotalLiquidStaked RPC method. +// Query/QueryTotalLiquidStaked RPC method. type QueryTotalLiquidStakedResponse struct { Tokens string `protobuf:"bytes,1,opt,name=tokens,proto3" json:"tokens,omitempty"` } diff --git a/x/liquid/types/tx.pb.go b/x/liquid/types/tx.pb.go index 79d9d167..4fb22095 100644 --- a/x/liquid/types/tx.pb.go +++ b/x/liquid/types/tx.pb.go @@ -732,73 +732,73 @@ func init() { func init() { proto.RegisterFile("kyve/liquid/v1beta1/tx.proto", fileDescriptor_a63931950704005e) } var fileDescriptor_a63931950704005e = []byte{ - // 1043 bytes of a gzipped FileDescriptorProto + // 1041 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x57, 0x4d, 0x6f, 0x1b, 0x45, 0x18, 0xf6, 0x24, 0x21, 0x8a, 0x87, 0xd2, 0x36, 0xdb, 0xb4, 0x75, 0xd6, 0xc1, 0x0e, 0x4b, 0x54, 0x42, 0x48, 0x77, 0x95, 0x14, 0xa8, 0xea, 0xf2, 0x15, 0xd3, 0x20, 0xaa, 0xca, 0x80, 0xb6, 0x01, 0x04, 0x1c, 0xac, 0xb1, 0x77, 0xba, 0x5e, 0xc5, 0xbb, 0x63, 0x66, 0xd6, 0x71, 0x53, 0x09, 0x09, 0x71, 0x42, 0x5c, 0xe8, 0x4f, 0x28, 0x07, 0x04, 0xe2, 0x94, 0x03, 0x08, 0xf1, 0x0f, 0x2a, 0xc1, 0xa1, 0x70, 0xe2, 0x14, 0xaa, 0xe4, 0x10, 0xce, 0xfd, 0x05, 0x68, 0x66, 0x67, 0xd7, 0x5f, 0xbb, - 0xfe, 0x68, 0xc9, 0x25, 0xf1, 0xcc, 0xf3, 0xbc, 0xef, 0xbc, 0xcf, 0x33, 0xef, 0xcc, 0xd8, 0x70, + 0xfe, 0x68, 0xc9, 0x25, 0xf1, 0xcc, 0xfb, 0xbc, 0xef, 0xbc, 0xcf, 0x33, 0xcf, 0xcc, 0xd8, 0x70, 0x61, 0x7b, 0x77, 0x07, 0x1b, 0x75, 0xe7, 0xf3, 0xa6, 0x63, 0x19, 0x3b, 0x6b, 0x15, 0xec, 0xa3, - 0x35, 0xc3, 0xbf, 0xad, 0x37, 0x28, 0xf1, 0x89, 0x72, 0x86, 0xa3, 0x7a, 0x80, 0xea, 0x12, 0x55, - 0x67, 0x91, 0xeb, 0x78, 0xc4, 0x10, 0x7f, 0x03, 0x9e, 0x9a, 0xab, 0x12, 0xe6, 0x12, 0x66, 0x54, - 0x10, 0xc3, 0x51, 0x96, 0x2a, 0x71, 0x3c, 0x89, 0x9f, 0x97, 0xb8, 0xcb, 0x6c, 0x63, 0x67, 0x8d, - 0xff, 0x93, 0xc0, 0x7c, 0x00, 0x94, 0xc5, 0xc8, 0x08, 0x06, 0x12, 0x9a, 0xb3, 0x89, 0x4d, 0x82, - 0x79, 0xfe, 0x49, 0xce, 0xe6, 0x6d, 0x42, 0xec, 0x3a, 0x36, 0xc4, 0xa8, 0xd2, 0xbc, 0x65, 0xf8, - 0x8e, 0x8b, 0x99, 0x8f, 0xdc, 0x86, 0x24, 0x2c, 0xc6, 0x09, 0x92, 0x0a, 0x04, 0x43, 0xfb, 0x0d, - 0xc0, 0x53, 0x25, 0x66, 0x7f, 0xd8, 0xb0, 0x90, 0x8f, 0x3f, 0x40, 0x14, 0xb9, 0x4c, 0x79, 0x15, - 0xa6, 0x51, 0xd3, 0xaf, 0x11, 0xea, 0xf8, 0xbb, 0x19, 0xb0, 0x08, 0x96, 0xd3, 0xc5, 0xcc, 0x5f, - 0x3f, 0x5f, 0x9c, 0x93, 0x15, 0x6d, 0x58, 0x16, 0xc5, 0x8c, 0xdd, 0xf4, 0xa9, 0xe3, 0xd9, 0x66, - 0x9b, 0xaa, 0xbc, 0x01, 0xa7, 0x1b, 0x22, 0x43, 0x66, 0x62, 0x11, 0x2c, 0x3f, 0xbd, 0x9e, 0xd5, - 0x63, 0x1c, 0xd3, 0x83, 0x45, 0x8a, 0xe9, 0xfb, 0xfb, 0xf9, 0xd4, 0x8f, 0x47, 0x7b, 0x2b, 0xc0, - 0x94, 0x51, 0x05, 0xfd, 0xab, 0xa3, 0xbd, 0x95, 0x76, 0xbe, 0x6f, 0x8e, 0xf6, 0x56, 0xb2, 0x36, - 0x72, 0x50, 0x28, 0xa0, 0xa7, 0x4e, 0x6d, 0x1e, 0x9e, 0xef, 0x99, 0x32, 0x31, 0x6b, 0x10, 0x8f, - 0x61, 0xed, 0xcf, 0x09, 0x38, 0x5b, 0x62, 0xf6, 0x16, 0xd9, 0xc6, 0x9e, 0x73, 0x07, 0xdf, 0xac, - 0x21, 0x8a, 0x99, 0x72, 0x1d, 0xce, 0x5a, 0xb8, 0x8e, 0x6d, 0xe4, 0x13, 0x5a, 0x46, 0x81, 0x0c, - 0x29, 0x70, 0xe1, 0xd1, 0x7e, 0x3e, 0xb3, 0x8b, 0xdc, 0x7a, 0x41, 0xeb, 0xa3, 0x68, 0xe6, 0xe9, - 0x68, 0x4e, 0x8a, 0xe7, 0xa9, 0x76, 0x50, 0xdd, 0xb1, 0xba, 0x52, 0x4d, 0xf4, 0xa6, 0xea, 0xa3, - 0x68, 0xe6, 0xe9, 0x68, 0x2e, 0x4c, 0x75, 0x19, 0x4e, 0x23, 0x97, 0x34, 0x3d, 0x3f, 0x33, 0x29, - 0x6c, 0x9b, 0xd7, 0xa5, 0xd1, 0xbc, 0x81, 0x22, 0xdb, 0xde, 0x26, 0x8e, 0x57, 0x9c, 0xe2, 0xa6, - 0x99, 0x92, 0xae, 0xac, 0xc3, 0xb3, 0xbe, 0x14, 0x68, 0x95, 0x19, 0x97, 0x58, 0x26, 0x2d, 0x0f, - 0xd3, 0xcc, 0x14, 0xaf, 0xc3, 0x3c, 0x13, 0x81, 0x42, 0xfe, 0xfb, 0x1c, 0x2a, 0x5c, 0xf9, 0xfa, - 0x5e, 0x3e, 0xf5, 0xef, 0xbd, 0x7c, 0x8a, 0x7b, 0xdd, 0xef, 0x06, 0xf7, 0xfc, 0x9c, 0xf0, 0xbc, - 0xcf, 0x3d, 0x6d, 0x0b, 0xce, 0xf7, 0x4d, 0x86, 0x86, 0x77, 0x88, 0x00, 0x63, 0x89, 0xd0, 0x1e, - 0x02, 0x98, 0x29, 0x31, 0xdb, 0xc4, 0x16, 0xc6, 0xae, 0x48, 0xce, 0xde, 0x21, 0xf4, 0xff, 0xdf, - 0xb0, 0x76, 0x81, 0x13, 0x63, 0x15, 0x58, 0x78, 0x6b, 0xb8, 0x63, 0xcf, 0x8a, 0x63, 0x96, 0xa4, - 0x42, 0xfb, 0x0c, 0x2e, 0x26, 0x61, 0x4f, 0xee, 0xdf, 0xef, 0x00, 0xe6, 0xf8, 0xb6, 0x50, 0xe4, - 0xb1, 0x5b, 0x98, 0x76, 0x6d, 0x8f, 0x89, 0xab, 0x84, 0x5a, 0xca, 0x65, 0x98, 0x09, 0x5b, 0x41, - 0xb6, 0x09, 0x15, 0x40, 0xd9, 0xb1, 0xc4, 0x6a, 0x53, 0x66, 0xd4, 0x47, 0x1d, 0x61, 0xd7, 0x2d, - 0xe5, 0x1c, 0x9c, 0x66, 0xd8, 0xb3, 0x30, 0x0d, 0x3a, 0xdb, 0x94, 0x23, 0x25, 0x0b, 0xd3, 0x1e, - 0x6e, 0xc9, 0x66, 0x9b, 0x14, 0xd0, 0x8c, 0x87, 0x5b, 0x41, 0x87, 0x5d, 0xed, 0xf4, 0x4b, 0x46, - 0x70, 0x93, 0x9e, 0x0f, 0x4d, 0x1a, 0x50, 0xaa, 0xb6, 0x0c, 0x2f, 0x0c, 0x66, 0x44, 0x27, 0xfc, - 0x87, 0xa0, 0x6f, 0xae, 0x39, 0x0c, 0x55, 0xea, 0xf8, 0xd8, 0x0e, 0xfa, 0x58, 0xdb, 0x1f, 0x5b, - 0x8c, 0xa6, 0x89, 0xed, 0x8f, 0xc5, 0x22, 0x35, 0xdf, 0x03, 0x71, 0x97, 0x6d, 0x7a, 0xc7, 0x2b, - 0xe6, 0xcd, 0xe1, 0x62, 0x16, 0x42, 0x31, 0x71, 0xb5, 0x68, 0x0d, 0x98, 0x4f, 0x80, 0xa2, 0x4e, - 0x2e, 0xc1, 0x53, 0x55, 0xe2, 0x36, 0xea, 0xd8, 0x77, 0x88, 0x57, 0xe6, 0x2f, 0x92, 0x6c, 0x69, - 0x55, 0x0f, 0x9e, 0x2b, 0x3d, 0x7c, 0xae, 0xf4, 0xad, 0xf0, 0xb9, 0x2a, 0xce, 0xf0, 0x9e, 0xbe, - 0xfb, 0x4f, 0x1e, 0x98, 0x27, 0xdb, 0xc1, 0x1c, 0xd6, 0xfe, 0x00, 0x70, 0xa9, 0xc4, 0xec, 0x8f, - 0x1d, 0xbf, 0x66, 0x51, 0xd4, 0x8a, 0x6d, 0x89, 0x16, 0xa2, 0x96, 0xf2, 0x3a, 0x7c, 0x46, 0x34, - 0x64, 0x8f, 0x45, 0x99, 0x47, 0xfb, 0xf9, 0xb9, 0xc0, 0xa2, 0x2e, 0x58, 0x33, 0x4f, 0x88, 0x71, - 0x78, 0x3f, 0x64, 0x61, 0xba, 0x7d, 0x2a, 0x26, 0xc4, 0xa9, 0x98, 0xa1, 0xf2, 0x20, 0x14, 0xde, - 0xed, 0xf4, 0xad, 0x7b, 0x19, 0xee, 0xd9, 0x8b, 0xa1, 0x67, 0x43, 0xab, 0xd4, 0x74, 0xb8, 0x3a, - 0x0a, 0x2f, 0x6a, 0x8c, 0x5f, 0x00, 0x7c, 0xa1, 0x23, 0x60, 0xa3, 0x5e, 0x3f, 0x2e, 0x07, 0x0a, - 0x37, 0x06, 0x8b, 0x5c, 0xed, 0x15, 0x39, 0xa8, 0x16, 0x6d, 0x0d, 0x8e, 0x4a, 0x0d, 0xa5, 0xae, - 0xff, 0x3a, 0x03, 0x27, 0x4b, 0xcc, 0x56, 0x2a, 0xf0, 0x44, 0xd7, 0xd7, 0x91, 0xa5, 0xd8, 0xaf, - 0x11, 0x3d, 0x2f, 0xbf, 0xba, 0x3a, 0x0a, 0x2b, 0x6a, 0xd2, 0x1a, 0x3c, 0xd9, 0x73, 0xca, 0x2e, - 0x24, 0xc5, 0x77, 0xf3, 0x54, 0x7d, 0x34, 0x5e, 0xb4, 0xd2, 0x17, 0xf0, 0x6c, 0xfc, 0xdb, 0x76, - 0x31, 0x29, 0x51, 0x2c, 0x5d, 0x7d, 0x65, 0x2c, 0x7a, 0xb4, 0xfc, 0xb7, 0x00, 0x66, 0x07, 0xbd, - 0x0d, 0x97, 0x12, 0xe5, 0x24, 0x07, 0xa9, 0x57, 0x1f, 0x23, 0xa8, 0xd3, 0x90, 0xf8, 0x4b, 0x3b, - 0xd1, 0x90, 0x58, 0x7a, 0xb2, 0x21, 0x03, 0x6f, 0x5a, 0xe5, 0x0e, 0x9c, 0x8b, 0xbd, 0x65, 0x13, - 0xfb, 0x27, 0x8e, 0xad, 0xbe, 0x3c, 0x0e, 0x3b, 0x5a, 0xfb, 0x3b, 0x00, 0x9f, 0x1b, 0x7e, 0x91, - 0x5d, 0x49, 0xca, 0x3d, 0x34, 0x54, 0xdd, 0x78, 0xec, 0xd0, 0xa8, 0xc6, 0x9f, 0x00, 0x5c, 0x1a, - 0xe9, 0xb6, 0x79, 0x6d, 0xd8, 0x5a, 0x83, 0xa2, 0xd5, 0x6b, 0x4f, 0x12, 0x1d, 0x16, 0xab, 0x3e, - 0xf5, 0x25, 0xff, 0x01, 0x51, 0xdc, 0xbc, 0x7f, 0x90, 0x03, 0x0f, 0x0e, 0x72, 0xe0, 0xe1, 0x41, - 0x0e, 0xdc, 0x3d, 0xcc, 0xa5, 0x1e, 0x1c, 0xe6, 0x52, 0x7f, 0x1f, 0xe6, 0x52, 0x9f, 0xbe, 0x64, - 0x3b, 0x7e, 0xad, 0x59, 0xd1, 0xab, 0xc4, 0x35, 0x6e, 0x7c, 0xf2, 0xd1, 0xe6, 0x7b, 0xd8, 0x6f, - 0x11, 0xba, 0x6d, 0x54, 0x6b, 0xc8, 0xf1, 0x8c, 0xdb, 0xe1, 0x2f, 0x0b, 0x7f, 0xb7, 0x81, 0x59, - 0x65, 0x5a, 0x3c, 0x4c, 0x97, 0xfe, 0x0b, 0x00, 0x00, 0xff, 0xff, 0x3e, 0x10, 0x0f, 0xdd, 0x07, - 0x0e, 0x00, 0x00, + 0x35, 0xc3, 0xbf, 0xad, 0x37, 0x28, 0xf1, 0x89, 0x72, 0x86, 0x47, 0xf5, 0x20, 0xaa, 0xcb, 0xa8, + 0x3a, 0x8b, 0x5c, 0xc7, 0x23, 0x86, 0xf8, 0x1b, 0xe0, 0xd4, 0x5c, 0x95, 0x30, 0x97, 0x30, 0xa3, + 0x82, 0x18, 0x8e, 0xaa, 0x54, 0x89, 0xe3, 0xc9, 0xf8, 0x79, 0x19, 0x77, 0x99, 0x6d, 0xec, 0xac, + 0xf1, 0x7f, 0x32, 0x30, 0x1f, 0x04, 0xca, 0x62, 0x64, 0x04, 0x03, 0x19, 0x9a, 0xb3, 0x89, 0x4d, + 0x82, 0x79, 0xfe, 0x49, 0xce, 0xe6, 0x6d, 0x42, 0xec, 0x3a, 0x36, 0xc4, 0xa8, 0xd2, 0xbc, 0x65, + 0xf8, 0x8e, 0x8b, 0x99, 0x8f, 0xdc, 0x86, 0x04, 0x2c, 0xc6, 0x11, 0x92, 0x0c, 0x04, 0x42, 0xfb, + 0x0d, 0xc0, 0x53, 0x25, 0x66, 0x7f, 0xd8, 0xb0, 0x90, 0x8f, 0x3f, 0x40, 0x14, 0xb9, 0x4c, 0x79, + 0x15, 0xa6, 0x51, 0xd3, 0xaf, 0x11, 0xea, 0xf8, 0xbb, 0x19, 0xb0, 0x08, 0x96, 0xd3, 0xc5, 0xcc, + 0x5f, 0x3f, 0x5f, 0x9c, 0x93, 0x1d, 0x6d, 0x58, 0x16, 0xc5, 0x8c, 0xdd, 0xf4, 0xa9, 0xe3, 0xd9, + 0x66, 0x1b, 0xaa, 0xbc, 0x01, 0xa7, 0x1b, 0xa2, 0x42, 0x66, 0x62, 0x11, 0x2c, 0x3f, 0xbd, 0x9e, + 0xd5, 0x63, 0x14, 0xd3, 0x83, 0x45, 0x8a, 0xe9, 0xfb, 0xfb, 0xf9, 0xd4, 0x8f, 0x47, 0x7b, 0x2b, + 0xc0, 0x94, 0x59, 0x05, 0xfd, 0xab, 0xa3, 0xbd, 0x95, 0x76, 0xbd, 0x6f, 0x8e, 0xf6, 0x56, 0xb2, + 0x9d, 0x04, 0x7a, 0xfa, 0xd4, 0xe6, 0xe1, 0xf9, 0x9e, 0x29, 0x13, 0xb3, 0x06, 0xf1, 0x18, 0xd6, + 0xfe, 0x9c, 0x80, 0xb3, 0x25, 0x66, 0x6f, 0x91, 0x6d, 0xec, 0x39, 0x77, 0xf0, 0xcd, 0x1a, 0xa2, + 0x98, 0x29, 0xd7, 0xe1, 0xac, 0x85, 0xeb, 0xd8, 0x46, 0x3e, 0xa1, 0x65, 0x14, 0xd0, 0x90, 0x04, + 0x17, 0x1e, 0xed, 0xe7, 0x33, 0xbb, 0xc8, 0xad, 0x17, 0xb4, 0x3e, 0x88, 0x66, 0x9e, 0x8e, 0xe6, + 0x24, 0x79, 0x5e, 0x6a, 0x07, 0xd5, 0x1d, 0xab, 0xab, 0xd4, 0x44, 0x6f, 0xa9, 0x3e, 0x88, 0x66, + 0x9e, 0x8e, 0xe6, 0xc2, 0x52, 0x97, 0xe1, 0x34, 0x72, 0x49, 0xd3, 0xf3, 0x33, 0x93, 0x42, 0xb6, + 0x79, 0x5d, 0x0a, 0xcd, 0x0d, 0x14, 0xc9, 0xf6, 0x36, 0x71, 0xbc, 0xe2, 0x14, 0x17, 0xcd, 0x94, + 0x70, 0x65, 0x1d, 0x9e, 0xf5, 0x25, 0x41, 0xab, 0xcc, 0x38, 0xc5, 0x32, 0x69, 0x79, 0x98, 0x66, + 0xa6, 0x78, 0x1f, 0xe6, 0x99, 0x28, 0x28, 0xe8, 0xbf, 0xcf, 0x43, 0x85, 0x2b, 0x5f, 0xdf, 0xcb, + 0xa7, 0xfe, 0xbd, 0x97, 0x4f, 0x71, 0xad, 0xfb, 0xd5, 0xe0, 0x9a, 0x9f, 0x13, 0x9a, 0xf7, 0xa9, + 0xa7, 0x6d, 0xc1, 0xf9, 0xbe, 0xc9, 0x50, 0xf0, 0x0e, 0x12, 0x60, 0x2c, 0x12, 0xda, 0x43, 0x00, + 0x33, 0x25, 0x66, 0x9b, 0xd8, 0xc2, 0xd8, 0x15, 0xc5, 0xd9, 0x3b, 0x84, 0xfe, 0xff, 0x1b, 0xd6, + 0x6e, 0x70, 0x62, 0xac, 0x06, 0x0b, 0x6f, 0x0d, 0x57, 0xec, 0xd9, 0x50, 0xb1, 0x58, 0x16, 0xda, + 0x67, 0x70, 0x31, 0x29, 0xf6, 0xe4, 0xfa, 0xfd, 0x0e, 0x60, 0x8e, 0x6f, 0x0b, 0x45, 0x1e, 0xbb, + 0x85, 0x69, 0xd7, 0xf6, 0x98, 0xb8, 0x4a, 0xa8, 0xa5, 0x5c, 0x86, 0x99, 0xd0, 0x0a, 0xd2, 0x26, + 0x54, 0x04, 0xca, 0x8e, 0x25, 0x56, 0x9b, 0x32, 0x23, 0x1f, 0x75, 0xa4, 0x5d, 0xb7, 0x94, 0x73, + 0x70, 0x9a, 0x61, 0xcf, 0xc2, 0x34, 0x70, 0xb6, 0x29, 0x47, 0x4a, 0x16, 0xa6, 0x3d, 0xdc, 0x92, + 0x66, 0x9b, 0x14, 0xa1, 0x19, 0x0f, 0xb7, 0x02, 0x87, 0x5d, 0xed, 0xd4, 0x4b, 0x66, 0x70, 0x91, + 0x9e, 0x8f, 0x6c, 0x95, 0xdc, 0xaa, 0xb6, 0x0c, 0x2f, 0x0c, 0x46, 0x44, 0x27, 0xfc, 0x87, 0xc0, + 0x37, 0xd7, 0x1c, 0x86, 0x2a, 0x75, 0x7c, 0x6c, 0x07, 0x7d, 0xac, 0xed, 0x8f, 0x6d, 0x46, 0xd3, + 0xc4, 0xf6, 0xc7, 0xc6, 0x22, 0x36, 0xdf, 0x03, 0x71, 0x97, 0x6d, 0x7a, 0xc7, 0x4b, 0xe6, 0xcd, + 0xe1, 0x64, 0x16, 0x42, 0x32, 0x71, 0xbd, 0x68, 0x0d, 0x98, 0x4f, 0x08, 0x45, 0x4e, 0x2e, 0xc1, + 0x53, 0x55, 0xe2, 0x36, 0xea, 0xd8, 0x77, 0x88, 0x57, 0xe6, 0x2f, 0x92, 0xb4, 0xb4, 0xaa, 0x07, + 0xcf, 0x95, 0x1e, 0x3e, 0x57, 0xfa, 0x56, 0xf8, 0x5c, 0x15, 0x67, 0xb8, 0xa7, 0xef, 0xfe, 0x93, + 0x07, 0xe6, 0xc9, 0x76, 0x32, 0x0f, 0x6b, 0x7f, 0x00, 0xb8, 0x54, 0x62, 0xf6, 0xc7, 0x8e, 0x5f, + 0xb3, 0x28, 0x6a, 0xc5, 0x5a, 0xa2, 0x85, 0xa8, 0xa5, 0xbc, 0x0e, 0x9f, 0x11, 0x86, 0xec, 0x91, + 0x28, 0xf3, 0x68, 0x3f, 0x3f, 0x17, 0x48, 0xd4, 0x15, 0xd6, 0xcc, 0x13, 0x62, 0x1c, 0xde, 0x0f, + 0x59, 0x98, 0x6e, 0x9f, 0x8a, 0x09, 0x71, 0x2a, 0x66, 0xa8, 0x3c, 0x08, 0x85, 0x77, 0x3b, 0x75, + 0xeb, 0x5e, 0x86, 0x6b, 0xf6, 0x62, 0xa8, 0xd9, 0xd0, 0x2e, 0x35, 0x1d, 0xae, 0x8e, 0x82, 0x8b, + 0x8c, 0xf1, 0x0b, 0x80, 0x2f, 0x74, 0x24, 0x6c, 0xd4, 0xeb, 0xc7, 0xa5, 0x40, 0xe1, 0xc6, 0x60, + 0x92, 0xab, 0xbd, 0x24, 0x07, 0xf5, 0xa2, 0xad, 0xc1, 0x51, 0xa1, 0x21, 0xd5, 0xf5, 0x5f, 0x67, + 0xe0, 0x64, 0x89, 0xd9, 0x4a, 0x05, 0x9e, 0xe8, 0xfa, 0x3a, 0xb2, 0x14, 0xfb, 0x35, 0xa2, 0xe7, + 0xe5, 0x57, 0x57, 0x47, 0x41, 0x45, 0x26, 0xad, 0xc1, 0x93, 0x3d, 0xa7, 0xec, 0x42, 0x52, 0x7e, + 0x37, 0x4e, 0xd5, 0x47, 0xc3, 0x45, 0x2b, 0x7d, 0x01, 0xcf, 0xc6, 0xbf, 0x6d, 0x17, 0x93, 0x0a, + 0xc5, 0xc2, 0xd5, 0x57, 0xc6, 0x82, 0x47, 0xcb, 0x7f, 0x0b, 0x60, 0x76, 0xd0, 0xdb, 0x70, 0x29, + 0x91, 0x4e, 0x72, 0x92, 0x7a, 0xf5, 0x31, 0x92, 0x3a, 0x05, 0x89, 0xbf, 0xb4, 0x13, 0x05, 0x89, + 0x85, 0x27, 0x0b, 0x32, 0xf0, 0xa6, 0x55, 0xee, 0xc0, 0xb9, 0xd8, 0x5b, 0x36, 0xd1, 0x3f, 0x71, + 0x68, 0xf5, 0xe5, 0x71, 0xd0, 0xd1, 0xda, 0xdf, 0x01, 0xf8, 0xdc, 0xf0, 0x8b, 0xec, 0x4a, 0x52, + 0xed, 0xa1, 0xa9, 0xea, 0xc6, 0x63, 0xa7, 0x46, 0x3d, 0xfe, 0x04, 0xe0, 0xd2, 0x48, 0xb7, 0xcd, + 0x6b, 0xc3, 0xd6, 0x1a, 0x94, 0xad, 0x5e, 0x7b, 0x92, 0xec, 0xb0, 0x59, 0xf5, 0xa9, 0x2f, 0xf9, + 0x0f, 0x88, 0xe2, 0xe6, 0xfd, 0x83, 0x1c, 0x78, 0x70, 0x90, 0x03, 0x0f, 0x0f, 0x72, 0xe0, 0xee, + 0x61, 0x2e, 0xf5, 0xe0, 0x30, 0x97, 0xfa, 0xfb, 0x30, 0x97, 0xfa, 0xf4, 0x25, 0xdb, 0xf1, 0x6b, + 0xcd, 0x8a, 0x5e, 0x25, 0xae, 0x71, 0xe3, 0x93, 0x8f, 0x36, 0xdf, 0xc3, 0x7e, 0x8b, 0xd0, 0x6d, + 0xa3, 0x5a, 0x43, 0x8e, 0x67, 0xdc, 0x0e, 0x7f, 0x59, 0xf8, 0xbb, 0x0d, 0xcc, 0x2a, 0xd3, 0xe2, + 0x61, 0xba, 0xf4, 0x5f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xea, 0xb9, 0x9a, 0x1d, 0x07, 0x0e, 0x00, + 0x00, } // Reference imports to suppress errors if they are not otherwise used.