diff --git a/.changelog/unreleased/improvements/provider/1445-query-provider-parameters.md b/.changelog/unreleased/improvements/provider/1445-query-provider-parameters.md
new file mode 100644
index 0000000000..f7ec62399d
--- /dev/null
+++ b/.changelog/unreleased/improvements/provider/1445-query-provider-parameters.md
@@ -0,0 +1,2 @@
+- Added query for current values of all provider parameters
+  ([\#1605](https://github.com/cosmos/interchain-security/pull/1605))
\ No newline at end of file
diff --git a/docs/docs/adrs/adr-005-cryptographic-equivocation-verification.md b/docs/docs/adrs/adr-005-cryptographic-equivocation-verification.md
index d4f9bd2bf8..890a04fceb 100644
--- a/docs/docs/adrs/adr-005-cryptographic-equivocation-verification.md
+++ b/docs/docs/adrs/adr-005-cryptographic-equivocation-verification.md
@@ -16,8 +16,8 @@ Accepted
 
 ## Context
 
-Currently, we use a governance proposal to slash validators for equivocation (double signing and light client attacks). 
-Every proposal needs to go through a (two weeks) voting period before it can be approved. 
+Currently, we use a governance proposal to slash validators for equivocation (double signing and light client attacks).
+Every proposal needs to go through a (two weeks) voting period before it can be approved.
 Given a three-week unbonding period, this means that an equivocation proposal needs to be submitted within one week since the infraction occurred.
 
 This ADR proposes a system to slash validators automatically for equivocation, immediately upon the provider chain's receipt of the evidence. Another thing to note is that we intend to introduce this system in stages, since even the partial ability to slash and/or tombstone is a strict improvement in security.
@@ -27,7 +27,7 @@ The feature is implemented in two parts, each with its dedicated endpoint. One e
 
 In a nutshell, the light client is a process that solely verifies a specific state machine's
 consensus without executing the transactions. The light clients get new headers by querying
-multiple nodes, called primary and witness nodes. 
+multiple nodes, called primary and witness nodes.
 
 Light clients download new headers committed on chain from a primary. Headers can be verified in two ways: sequentially,
 where the block height of headers is serial, or using skipping. This second verification method allows light clients to download headers
@@ -41,7 +41,7 @@ and both headers are successfully verified, it indicates a light client attack.
 Note that in this case, either the primary or the witness or both are malicious.
 
 The types of light client attacks are defined by analyzing the differences between the conflicting headers.
-There are three types of light client attacks: lunatic attack, equivocation attack, and amnesia attack. 
+There are three types of light client attacks: lunatic attack, equivocation attack, and amnesia attack.
 For details, see the [CometBFT specification](https://github.com/cometbft/cometbft/blob/main/spec/light-client/attacks/notes-on-evidence-handling.md#evidence-handling).
 
 When a light client agent detects two conflicting headers, it will initially verify their traces (see [cometBFT detector](https://github.com/cometbft/cometbft/blob/v0.34.28/light/detector.go#L28)) using its primary and witness nodes.
@@ -61,22 +61,22 @@ light client, halting any further trust in or updating of its states.
 
 ### Double Signing Attack
 
-A double signing attack, also known as equivocation, 
-occurs when a validator votes for two different blocks in the same round of the CometBFT consensus. 
-This consensus mechanism operates with multiple voting rounds at each block height, 
-and it strictly prohibits sending two votes of the same type during a round 
+A double signing attack, also known as equivocation,
+occurs when a validator votes for two different blocks in the same round of the CometBFT consensus.
+This consensus mechanism operates with multiple voting rounds at each block height,
+and it strictly prohibits sending two votes of the same type during a round
 (see [CometBFT State Machine Overview](https://github.com/cometbft/cometbft/blob/v0.34.28/spec/consensus/consensus.md#state-machine-overview)).
 
-When a node observes two votes from the same peer, it will use these two votes to create 
-a [`DuplicateVoteEvidence`](https://github.com/cometbft/cometbft/blob/v0.34.28/types/evidence.go#L35) 
-evidence and gossip it to the other nodes in the network 
-(see [CometBFT equivocation detection](https://github.com/cometbft/cometbft/blob/v0.34.28/spec/consensus/evidence.md#detection)). 
-Each node will then verify the evidence according to the CometBFT rules that define a valid double signing infraction, and based on this verification, they will decide whether to add the evidence to a block. 
-During the evidence verification process, the signatures of the conflicting votes must be verified successfully. 
+When a node observes two votes from the same peer, it will use these two votes to create
+a [`DuplicateVoteEvidence`](https://github.com/cometbft/cometbft/blob/v0.34.28/types/evidence.go#L35)
+evidence and gossip it to the other nodes in the network
+(see [CometBFT equivocation detection](https://github.com/cometbft/cometbft/blob/v0.34.28/spec/consensus/evidence.md#detection)).
+Each node will then verify the evidence according to the CometBFT rules that define a valid double signing infraction, and based on this verification, they will decide whether to add the evidence to a block.
+During the evidence verification process, the signatures of the conflicting votes must be verified successfully.
 Note that this is achieved using the public key of the misbehaving validator, along with the chain ID of the chain where the infraction occurred (see [CometBFT equivocation verification](https://github.com/cometbft/cometbft/blob/v0.34.28/spec/consensus/evidence.md#verification)).
 
-Once a double signing evidence is committed to a block, the consensus layer will report the equivocation to the evidence module of the Cosmos SDK application layer. 
-The application will, in turn, punish the malicious validator through jailing, tombstoning and slashing 
+Once a double signing evidence is committed to a block, the consensus layer will report the equivocation to the evidence module of the Cosmos SDK application layer.
+The application will, in turn, punish the malicious validator through jailing, tombstoning and slashing
 (see [handleEquivocationEvidence](https://github.com/cosmos/cosmos-sdk/blob/v0.45.16-ics-lsm/x/evidence/keeper/infraction.go#L263)).
 
 
@@ -87,7 +87,7 @@ The application will, in turn, punish the malicious validator through jailing, t
 In the first part of the feature, we introduce a new endpoint: `HandleConsumerMisbehaviour(ctx sdk.Context, misbehaviour ibctmtypes.Misbehaviour)`.
 The main idea is to leverage the current IBC misbehaviour handling and update it to solely jail and slash the validators that
 performed a light client attack. Note that in this context, we assume that chains connected via a light client
-share the same validator set, as is the case with Replicated Security. 
+share the same validator set, as is the case with Replicated Security.
 
 This endpoint reuses the IBC client libraries to verify that the misbehaviour headers would have fooled the light client.
 Additionally, it’s crucial that the endpoint logic results in the slashing and jailing of validators under the same conditions
@@ -95,29 +95,29 @@ as a light client agent detector. Therefore, the endpoint ensures that the two c
 the headers in the misbehaviour message have the same block height, and
 the light client isn’t expired.
 
-After having successfully verified a misbehaviour, the endpoint executes the jailing and slashing of the malicious validators similarly as in the evidence module. 
+After having successfully verified a misbehaviour, the endpoint executes the jailing and slashing of the malicious validators similarly as in the evidence module.
 
 ### Double Signing Attack
 
 In the second part of the feature, we introduce a new endpoint `HandleConsumerDoubleVoting(
-ctx sdk.Context, evidence *tmtypes.DuplicateVoteEvidence, chainID string, pubkey cryptotypes.PubKey)`. 
-Simply put, the handling logic verifies a double signing evidence against a provided 
+ctx sdk.Context, evidence *tmtypes.DuplicateVoteEvidence, chainID string, pubkey cryptotypes.PubKey)`.
+Simply put, the handling logic verifies a double signing evidence against a provided
 public key and chain ID and, if successful, executes the jailing of the malicious validator who double voted.
-  
-We define a new 
-`MsgSubmitConsumerDoubleVoting` message to report a double voting evidence observed 
-on a consumer chain to the endpoint of the provider chain. This message contains two fields: 
-a double signing evidence 
-`duplicate_vote_evidence` and a light client header for the infraction block height, 
-referred to as `infraction_block_header`. 
+
+We define a new
+`MsgSubmitConsumerDoubleVoting` message to report a double voting evidence observed
+on a consumer chain to the endpoint of the provider chain. This message contains two fields:
+a double signing evidence
+`duplicate_vote_evidence` and a light client header for the infraction block height,
+referred to as `infraction_block_header`.
 The latter provides the malicious validator's public key and the chain ID required to verify the signature of the votes contained in the evidence.
- 
+
 Note that double signing evidence is not verified using the same conditions as in the implementation CometBFT (see
-[`verify(evidence types.Evidence)`](https://github.com/cometbft/cometbft/blob/v0.34.28/evidence/verify.go#L19) method). Specifically, we do not check that the evidence hasn't expired. 
-More details can be found in the ["Current limitations"](#current-limitations) section below. 
-  
-Upon a successful equivocation verification, the misbehaving validator is jailed for the maximum time 
-(see [DoubleSignJailEndTime](https://github.com/cosmos/cosmos-sdk/blob/v0.45.16-ics-lsm/x/evidence/types/params.go#L11) 
+[`verify(evidence types.Evidence)`](https://github.com/cometbft/cometbft/blob/v0.34.28/evidence/verify.go#L19) method). Specifically, we do not check that the evidence hasn't expired.
+More details can be found in the ["Current limitations"](#current-limitations) section below.
+
+Upon a successful equivocation verification, the misbehaving validator is jailed for the maximum time
+(see [DoubleSignJailEndTime](https://github.com/cosmos/cosmos-sdk/blob/v0.45.16-ics-lsm/x/evidence/types/params.go#L11)
 in the SDK evidence module).
 
 
@@ -131,21 +131,21 @@ To explain the technical reasons behind this limitation, let's recap the initial
  which is used to slash the misbehaving validator. In the context of untrusted consumer chains, all their states, including vscIDs,
  could be corrupted and therefore cannot be used for slashing purposes.
 
-- For the same reasons explained above, the age of a consumer double signing evidence can't be verified, 
+- For the same reasons explained above, the age of a consumer double signing evidence can't be verified,
 either using its infraction height or its unsigned timestamp. Note that changes the jailing behaviour, potentially leading to a validator's jailing based on some "old" evidence from a consumer, which wouldn't occur if the consumer were a standalone chain.
 
 - In the first stage of this feature, validators are jailed indefinitely without being tombstoned.
-The underlying reason is that a malicious validator could take advantage of getting tombstoned 
-to avoid being slashed on the provider ([see comment](https://github.com/cosmos/interchain-security/pull/1232#issuecomment-1693127641)). 
+The underlying reason is that a malicious validator could take advantage of getting tombstoned
+to avoid being slashed on the provider ([see comment](https://github.com/cosmos/interchain-security/pull/1232#issuecomment-1693127641)).
 
-- Currently, the endpoint can only handle _equivocation_ light client attacks. This is because the _lunatic_ attacks require the endpoint to possess the ability to dissociate which header is conflicted or trusted upon receiving a misbehavior message. Without this information, it's not possible to extract the Byzantine validators from the conflicting headers (see [comment](https://github.com/cosmos/interchain-security/pull/826#discussion_r1268668684)). In addition, "amnesia" attacks are ignored, similar to CometBFT (see [ADR-056](https://github.com/cometbft/cometbft/blob/main/docs/architecture/tendermint-core/adr-056-light-client-amnesia-attacks.md#decision)).
+- Currently, the endpoint can only handle _equivocation_ light client attacks. This is because the _lunatic_ attacks require the endpoint to possess the ability to dissociate which header is conflicted or trusted upon receiving a misbehavior message. Without this information, it's not possible to extract the Byzantine validators from the conflicting headers (see [comment](https://github.com/cosmos/interchain-security/pull/826#discussion_r1268668684)). In addition, "amnesia" attacks are ignored, similar to CometBFT (see [ADR-056](https://github.com/cometbft/cometbft/blob/main/docs/references/architecture/tendermint-core/adr-056-light-client-amnesia-attacks.md#decision)).
 
 
 ## Consequences
 
 ### Positive
 
-- It is now possible for the provider chain to jail validators who committed 
+- It is now possible for the provider chain to jail validators who committed
 light client or double signing attacks on a consumer chain.
 
 ### Negative
diff --git a/proto/interchain_security/ccv/provider/v1/query.proto b/proto/interchain_security/ccv/provider/v1/query.proto
index 41d81da04d..f7d41a7715 100644
--- a/proto/interchain_security/ccv/provider/v1/query.proto
+++ b/proto/interchain_security/ccv/provider/v1/query.proto
@@ -99,7 +99,14 @@ service Query {
     returns (QueryAllPairsValConAddrByConsumerChainIDResponse) {
       option (google.api.http).get =
     "/interchain_security/ccv/provider/consumer_chain_id";
-    }  
+    }
+
+  // QueryParams returns all current values of provider parameters
+  rpc QueryParams(QueryParamsRequest)
+    returns (QueryParamsResponse) {
+      option (google.api.http).get =
+    "/interchain_security/ccv/provider/params";
+    }
 }
 
 message QueryConsumerGenesisRequest { string chain_id = 1; }
@@ -235,3 +242,10 @@ message PairValConAddrProviderAndConsumer {
   string consumer_address = 2 [ (gogoproto.moretags) = "yaml:\"address\"" ];
   tendermint.crypto.PublicKey consumer_key = 3;
 }
+
+message QueryParamsRequest {}
+
+message QueryParamsResponse {
+  Params params = 1 [(gogoproto.nullable) = false];
+}
+
diff --git a/x/ccv/provider/client/cli/query.go b/x/ccv/provider/client/cli/query.go
index a61d89949f..e59c892e98 100644
--- a/x/ccv/provider/client/cli/query.go
+++ b/x/ccv/provider/client/cli/query.go
@@ -35,7 +35,7 @@ func NewQueryCmd() *cobra.Command {
 	cmd.AddCommand(CmdRegisteredConsumerRewardDenoms())
 	cmd.AddCommand(CmdProposedConsumerChains())
 	cmd.AddCommand(CmdAllPairsValConAddrByConsumerChainID())
-
+	cmd.AddCommand(CmdProviderParameters())
 	return cmd
 }
 
@@ -412,3 +412,37 @@ func CmdAllPairsValConAddrByConsumerChainID() *cobra.Command {
 
 	return cmd
 }
+
+// Command to query provider parameters
+func CmdProviderParameters() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "params",
+		Short: "Query provider parameters information",
+		Long: strings.TrimSpace(
+			fmt.Sprintf(`Query parameter values of provider.
+Example:
+$ %s query provider params
+		`, version.AppName),
+		),
+		Args: cobra.NoArgs,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			clientCtx, err := client.GetClientQueryContext(cmd)
+			if err != nil {
+				return err
+			}
+			queryClient := types.NewQueryClient(clientCtx)
+
+			res, err := queryClient.QueryParams(cmd.Context(),
+				&types.QueryParamsRequest{})
+			if err != nil {
+				return err
+			}
+
+			return clientCtx.PrintProto(&res.Params)
+		},
+	}
+
+	flags.AddQueryFlagsToCmd(cmd)
+
+	return cmd
+}
diff --git a/x/ccv/provider/keeper/grpc_query.go b/x/ccv/provider/keeper/grpc_query.go
index a9680aec44..764d03f193 100644
--- a/x/ccv/provider/keeper/grpc_query.go
+++ b/x/ccv/provider/keeper/grpc_query.go
@@ -298,3 +298,11 @@ func (k Keeper) QueryAllPairsValConAddrByConsumerChainID(goCtx context.Context,
 		PairValConAddr: pairValConAddrs,
 	}, nil
 }
+
+// QueryParams returns all parameters and current values of provider
+func (k Keeper) QueryParams(c context.Context, _ *types.QueryParamsRequest) (*types.QueryParamsResponse, error) {
+	ctx := sdk.UnwrapSDKContext(c)
+	params := k.GetParams(ctx)
+
+	return &types.QueryParamsResponse{Params: params}, nil
+}
diff --git a/x/ccv/provider/types/provider.pb.go b/x/ccv/provider/types/provider.pb.go
index 2d800c5275..b527e86573 100644
--- a/x/ccv/provider/types/provider.pb.go
+++ b/x/ccv/provider/types/provider.pb.go
@@ -1425,113 +1425,115 @@ func init() {
 }
 
 var fileDescriptor_f22ec409a72b7b72 = []byte{
-	// 1694 bytes of a gzipped FileDescriptorProto
+	// 1716 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x58, 0xcd, 0x72, 0x1b, 0xc7,
-	0x11, 0xe6, 0x12, 0x20, 0x45, 0x34, 0xf8, 0xa7, 0x25, 0x6d, 0x2d, 0x15, 0x06, 0xa4, 0xd6, 0xb1,
-	0xc3, 0x94, 0xcb, 0x8b, 0x90, 0xaa, 0x54, 0xb9, 0x54, 0x71, 0xb9, 0x48, 0x50, 0xb6, 0x28, 0xc6,
-	0x16, 0xbd, 0x64, 0xa8, 0x4a, 0x72, 0xd8, 0x1a, 0xcc, 0x8e, 0x80, 0x29, 0x2e, 0x76, 0x56, 0x33,
-	0xb3, 0x2b, 0xe3, 0x92, 0x73, 0x8e, 0xce, 0xcd, 0x95, 0x4b, 0x9c, 0xbc, 0x40, 0xce, 0x79, 0x03,
-	0x1f, 0x7d, 0xcc, 0xc9, 0x4e, 0x51, 0xc7, 0xbc, 0x44, 0x6a, 0x66, 0xff, 0x41, 0x52, 0x81, 0x4a,
-	0xf1, 0x6d, 0xb6, 0xa7, 0xfb, 0xeb, 0x9e, 0xe9, 0xee, 0xaf, 0x07, 0x80, 0x3d, 0x1a, 0x4a, 0xc2,
-	0xf1, 0x10, 0xd1, 0xd0, 0x13, 0x04, 0xc7, 0x9c, 0xca, 0x71, 0x17, 0xe3, 0xa4, 0x1b, 0x71, 0x96,
-	0x50, 0x9f, 0xf0, 0x6e, 0xb2, 0x5b, 0xac, 0x9d, 0x88, 0x33, 0xc9, 0xcc, 0x77, 0xae, 0xb1, 0x71,
-	0x30, 0x4e, 0x9c, 0x42, 0x2f, 0xd9, 0xbd, 0xfb, 0xee, 0x4d, 0xc0, 0xc9, 0x6e, 0xf7, 0x05, 0xe5,
-	0x24, 0xc5, 0xba, 0xbb, 0x3e, 0x60, 0x03, 0xa6, 0x97, 0x5d, 0xb5, 0xca, 0xa4, 0x5b, 0x03, 0xc6,
-	0x06, 0x01, 0xe9, 0xea, 0xaf, 0x7e, 0xfc, 0xac, 0x2b, 0xe9, 0x88, 0x08, 0x89, 0x46, 0x51, 0xa6,
-	0xd0, 0x99, 0x54, 0xf0, 0x63, 0x8e, 0x24, 0x65, 0x61, 0x0e, 0x40, 0xfb, 0xb8, 0x8b, 0x19, 0x27,
-	0x5d, 0x1c, 0x50, 0x12, 0x4a, 0xe5, 0x35, 0x5d, 0x65, 0x0a, 0x5d, 0xa5, 0x10, 0xd0, 0xc1, 0x50,
-	0xa6, 0x62, 0xd1, 0x95, 0x24, 0xf4, 0x09, 0x1f, 0xd1, 0x54, 0xb9, 0xfc, 0xca, 0x0c, 0x36, 0x2b,
-	0xfb, 0x98, 0x8f, 0x23, 0xc9, 0xba, 0x17, 0x64, 0x2c, 0xb2, 0xdd, 0xf7, 0x30, 0x13, 0x23, 0x26,
-	0xba, 0x44, 0x9d, 0x3f, 0xc4, 0xa4, 0x9b, 0xec, 0xf6, 0x89, 0x44, 0xbb, 0x85, 0x20, 0x8f, 0x3b,
-	0xd3, 0xeb, 0x23, 0x51, 0xea, 0x60, 0x46, 0xb3, 0xb8, 0xed, 0x1f, 0xe6, 0xc1, 0xea, 0xb1, 0x50,
-	0xc4, 0x23, 0xc2, 0xf7, 0x7d, 0x9f, 0xaa, 0x23, 0x9d, 0x70, 0x16, 0x31, 0x81, 0x02, 0x73, 0x1d,
-	0xe6, 0x24, 0x95, 0x01, 0xb1, 0x8c, 0x6d, 0x63, 0xa7, 0xe5, 0xa6, 0x1f, 0xe6, 0x36, 0xb4, 0x7d,
-	0x22, 0x30, 0xa7, 0x91, 0x52, 0xb6, 0x66, 0xf5, 0x5e, 0x55, 0x64, 0x6e, 0xc0, 0x42, 0x9a, 0x07,
-	0xea, 0x5b, 0x0d, 0xbd, 0x7d, 0x4b, 0x7f, 0x1f, 0xf9, 0xe6, 0xa7, 0xb0, 0x4c, 0x43, 0x2a, 0x29,
-	0x0a, 0xbc, 0x21, 0x51, 0xb7, 0x61, 0x35, 0xb7, 0x8d, 0x9d, 0xf6, 0xde, 0x5d, 0x87, 0xf6, 0xb1,
-	0xa3, 0x2e, 0xd0, 0xc9, 0xae, 0x2d, 0xd9, 0x75, 0x1e, 0x69, 0x8d, 0x83, 0xe6, 0xb7, 0xdf, 0x6f,
-	0xcd, 0xb8, 0x4b, 0x99, 0x5d, 0x2a, 0x34, 0xef, 0xc1, 0xe2, 0x80, 0x84, 0x44, 0x50, 0xe1, 0x0d,
-	0x91, 0x18, 0x5a, 0x73, 0xdb, 0xc6, 0xce, 0xa2, 0xdb, 0xce, 0x64, 0x8f, 0x90, 0x18, 0x9a, 0x5b,
-	0xd0, 0xee, 0xd3, 0x10, 0xf1, 0x71, 0xaa, 0x31, 0xaf, 0x35, 0x20, 0x15, 0x69, 0x85, 0x1e, 0x80,
-	0x88, 0xd0, 0x8b, 0xd0, 0x53, 0xd9, 0xb6, 0x6e, 0x65, 0x81, 0xa4, 0x99, 0x76, 0xf2, 0x4c, 0x3b,
-	0x67, 0x79, 0x29, 0x1c, 0x2c, 0xa8, 0x40, 0xbe, 0xfa, 0x61, 0xcb, 0x70, 0x5b, 0xda, 0x4e, 0xed,
-	0x98, 0x9f, 0xc3, 0x6a, 0x1c, 0xf6, 0x59, 0xe8, 0xd3, 0x70, 0xe0, 0x45, 0x84, 0x53, 0xe6, 0x5b,
-	0x0b, 0x1a, 0x6a, 0xe3, 0x0a, 0xd4, 0x61, 0x56, 0x34, 0x29, 0xd2, 0xd7, 0x0a, 0x69, 0xa5, 0x30,
-	0x3e, 0xd1, 0xb6, 0xe6, 0x17, 0x60, 0x62, 0x9c, 0xe8, 0x90, 0x58, 0x2c, 0x73, 0xc4, 0xd6, 0xf4,
-	0x88, 0xab, 0x18, 0x27, 0x67, 0xa9, 0x75, 0x06, 0xf9, 0x07, 0xb8, 0x23, 0x39, 0x0a, 0xc5, 0x33,
-	0xc2, 0x27, 0x71, 0x61, 0x7a, 0xdc, 0xb7, 0x72, 0x8c, 0x3a, 0xf8, 0x23, 0xd8, 0xc6, 0x59, 0x01,
-	0x79, 0x9c, 0xf8, 0x54, 0x48, 0x4e, 0xfb, 0xb1, 0xb2, 0xf5, 0x9e, 0x71, 0x84, 0x75, 0x8d, 0xb4,
-	0x75, 0x11, 0x74, 0x72, 0x3d, 0xb7, 0xa6, 0xf6, 0x49, 0xa6, 0x65, 0x3e, 0x81, 0x9f, 0xf5, 0x03,
-	0x86, 0x2f, 0x84, 0x0a, 0xce, 0xab, 0x21, 0x69, 0xd7, 0x23, 0x2a, 0x84, 0x42, 0x5b, 0xdc, 0x36,
-	0x76, 0x1a, 0xee, 0xbd, 0x54, 0xf7, 0x84, 0xf0, 0xc3, 0x8a, 0xe6, 0x59, 0x45, 0xd1, 0xfc, 0x00,
-	0xcc, 0x21, 0x15, 0x92, 0x71, 0x8a, 0x51, 0xe0, 0x91, 0x50, 0x72, 0x4a, 0x84, 0xb5, 0xa4, 0xcd,
-	0x6f, 0x97, 0x3b, 0x0f, 0xd3, 0x0d, 0xf3, 0x31, 0xdc, 0xbb, 0xd1, 0xa9, 0x87, 0x87, 0x28, 0x0c,
-	0x49, 0x60, 0x2d, 0xeb, 0xa3, 0x6c, 0xf9, 0x37, 0xf8, 0xec, 0xa5, 0x6a, 0x0f, 0x16, 0xfe, 0xf4,
-	0xcd, 0xd6, 0xcc, 0xd7, 0xdf, 0x6c, 0xcd, 0xd8, 0xff, 0x30, 0xe0, 0x4e, 0xaf, 0x38, 0xf8, 0x88,
-	0x25, 0x28, 0xf8, 0x31, 0x1b, 0x6c, 0x1f, 0x5a, 0x42, 0xb2, 0x28, 0x2d, 0xe9, 0xe6, 0x6b, 0x94,
-	0xf4, 0x82, 0x32, 0x53, 0x1b, 0xf6, 0x5f, 0x0d, 0x58, 0x7f, 0xf8, 0x3c, 0xa6, 0x09, 0xc3, 0xe8,
-	0xff, 0xc2, 0x07, 0xc7, 0xb0, 0x44, 0x2a, 0x78, 0xc2, 0x6a, 0x6c, 0x37, 0x76, 0xda, 0x7b, 0xef,
-	0x3a, 0x29, 0x39, 0x39, 0x05, 0x67, 0x65, 0x04, 0xe5, 0x54, 0xbd, 0xbb, 0x75, 0xdb, 0x07, 0xb3,
-	0x96, 0x61, 0xff, 0xdd, 0x80, 0xbb, 0xea, 0xa6, 0x07, 0xc4, 0x25, 0x2f, 0x10, 0xf7, 0x0f, 0x49,
-	0xc8, 0x46, 0xe2, 0x8d, 0xe3, 0xb4, 0x61, 0xc9, 0xd7, 0x48, 0x9e, 0x64, 0x1e, 0xf2, 0x7d, 0x1d,
-	0xa7, 0xd6, 0x51, 0xc2, 0x33, 0xb6, 0xef, 0xfb, 0xe6, 0x0e, 0xac, 0x96, 0x3a, 0x5c, 0xe5, 0x53,
-	0x5d, 0xb3, 0x52, 0x5b, 0xce, 0xd5, 0x74, 0x96, 0x89, 0xfd, 0x1f, 0x03, 0x56, 0x3f, 0x0d, 0x58,
-	0x1f, 0x05, 0xa7, 0x01, 0x12, 0x43, 0x55, 0x65, 0x63, 0x95, 0x1e, 0x4e, 0xb2, 0xf6, 0xd6, 0xe1,
-	0x4d, 0x9d, 0x1e, 0x65, 0xa6, 0x09, 0xe7, 0x63, 0xb8, 0x5d, 0x34, 0x5c, 0x51, 0x05, 0xfa, 0x34,
-	0x07, 0x6b, 0x97, 0xdf, 0x6f, 0xad, 0xe4, 0xc5, 0xd6, 0xd3, 0x15, 0x71, 0xe8, 0xae, 0xe0, 0x9a,
-	0xc0, 0x37, 0x3b, 0xd0, 0xa6, 0x7d, 0xec, 0x09, 0xf2, 0xdc, 0x0b, 0xe3, 0x91, 0x2e, 0xa0, 0xa6,
-	0xdb, 0xa2, 0x7d, 0x7c, 0x4a, 0x9e, 0x7f, 0x1e, 0x8f, 0xcc, 0xfb, 0xf0, 0x76, 0x3e, 0x58, 0xbd,
-	0x04, 0x05, 0x9e, 0xb2, 0x57, 0xd7, 0xc1, 0x75, 0x3d, 0x2d, 0xba, 0x6b, 0xf9, 0xee, 0x39, 0x0a,
-	0x94, 0xb3, 0x7d, 0xdf, 0xe7, 0xf6, 0x3f, 0xe7, 0x60, 0xfe, 0x04, 0x71, 0x34, 0x12, 0xe6, 0x19,
-	0xac, 0x48, 0x32, 0x8a, 0x02, 0x24, 0x89, 0x97, 0x92, 0x79, 0x76, 0xd2, 0xf7, 0x35, 0xc9, 0x57,
-	0x87, 0xa0, 0x53, 0x19, 0x7b, 0xc9, 0xae, 0xd3, 0xd3, 0xd2, 0x53, 0x89, 0x24, 0x71, 0x97, 0x73,
-	0x8c, 0x54, 0x68, 0x7e, 0x08, 0x96, 0xe4, 0xb1, 0x90, 0x25, 0xcd, 0x96, 0xfc, 0x92, 0xe6, 0xf2,
-	0xed, 0x7c, 0x3f, 0x65, 0xa6, 0x82, 0x57, 0xae, 0x67, 0xd4, 0xc6, 0x9b, 0x30, 0xea, 0x29, 0xac,
-	0xa9, 0x71, 0x34, 0x89, 0xd9, 0x9c, 0x1e, 0xf3, 0xb6, 0xb2, 0xaf, 0x83, 0x7e, 0x01, 0x66, 0x22,
-	0xf0, 0x24, 0xe6, 0xdc, 0x6b, 0xc4, 0x99, 0x08, 0x5c, 0x87, 0xf4, 0x61, 0x53, 0xa8, 0xe2, 0xf3,
-	0x46, 0x44, 0x6a, 0x7e, 0x8e, 0x02, 0x12, 0x52, 0x31, 0xcc, 0xc1, 0xe7, 0xa7, 0x07, 0xdf, 0xd0,
-	0x40, 0x9f, 0x29, 0x1c, 0x37, 0x87, 0xc9, 0xbc, 0xf4, 0xa0, 0x73, 0xbd, 0x97, 0x22, 0x41, 0xb7,
-	0x74, 0x82, 0x7e, 0x72, 0x0d, 0x44, 0x91, 0x25, 0x01, 0xef, 0x55, 0xe6, 0x88, 0xea, 0x6a, 0x4f,
-	0x37, 0x94, 0xc7, 0xc9, 0x40, 0x91, 0x2d, 0x4a, 0x47, 0x0a, 0x21, 0xc5, 0x2c, 0xcc, 0xd8, 0x43,
-	0x3d, 0x6d, 0x0a, 0xe6, 0xe8, 0x31, 0x1a, 0x66, 0x0f, 0x06, 0xbb, 0x1c, 0x37, 0x05, 0x47, 0xb8,
-	0x15, 0xac, 0x4f, 0x08, 0x79, 0xdc, 0x5c, 0x58, 0x58, 0x6d, 0xd9, 0xbf, 0x80, 0x96, 0x6e, 0xd1,
-	0x7d, 0x7c, 0x21, 0xcc, 0x4d, 0x68, 0xa9, 0x5a, 0x27, 0x42, 0x10, 0x61, 0x19, 0xba, 0xb3, 0x4b,
-	0x81, 0x2d, 0x61, 0xe3, 0xa6, 0xe7, 0x92, 0x30, 0x9f, 0xc2, 0xad, 0x88, 0xe8, 0x59, 0xae, 0x0d,
-	0xdb, 0x7b, 0x1f, 0x39, 0x53, 0xbc, 0x5c, 0x9d, 0x9b, 0x00, 0xdd, 0x1c, 0xcd, 0xe6, 0xe5, 0x23,
-	0x6d, 0x62, 0x84, 0x08, 0xf3, 0x7c, 0xd2, 0xe9, 0xaf, 0x5f, 0xcb, 0xe9, 0x04, 0x5e, 0xe9, 0xf3,
-	0x7d, 0x68, 0xef, 0xa7, 0xc7, 0xfe, 0x0d, 0x15, 0xf2, 0xea, 0xb5, 0x2c, 0x56, 0xaf, 0xe5, 0x31,
-	0x2c, 0x67, 0x93, 0xef, 0x8c, 0x69, 0x9a, 0x31, 0x7f, 0x0a, 0x90, 0x8d, 0x4c, 0x45, 0x4f, 0x29,
-	0x11, 0xb7, 0x32, 0xc9, 0x91, 0x5f, 0x9b, 0x60, 0xb3, 0xb5, 0x09, 0x66, 0xbb, 0xb0, 0x72, 0x2e,
-	0xf0, 0x6f, 0xf3, 0x67, 0xd1, 0x93, 0x48, 0x98, 0x6f, 0xc1, 0xbc, 0xea, 0x8c, 0x0c, 0xa8, 0xe9,
-	0xce, 0x25, 0x02, 0x1f, 0x69, 0x2e, 0x2e, 0x9f, 0x5e, 0x2c, 0xf2, 0xa8, 0x2f, 0xac, 0xd9, 0xed,
-	0xc6, 0x4e, 0xd3, 0x5d, 0x8e, 0x4b, 0xf3, 0x23, 0x5f, 0xd8, 0xbf, 0x83, 0x76, 0x05, 0xd0, 0x5c,
-	0x86, 0xd9, 0x02, 0x6b, 0x96, 0xfa, 0xe6, 0x03, 0xd8, 0x28, 0x81, 0xea, 0xe4, 0x9a, 0x22, 0xb6,
-	0xdc, 0x3b, 0x85, 0x42, 0x8d, 0x5f, 0x85, 0xfd, 0x04, 0xd6, 0x8f, 0xca, 0x56, 0x2e, 0xa8, 0xbb,
-	0x76, 0x42, 0xa3, 0x3e, 0xa3, 0x37, 0xa1, 0x55, 0xfc, 0xbe, 0xd0, 0xa7, 0x6f, 0xba, 0xa5, 0xc0,
-	0x1e, 0xc1, 0xea, 0xb9, 0xc0, 0xa7, 0x24, 0xf4, 0x4b, 0xb0, 0x1b, 0x2e, 0xe0, 0x60, 0x12, 0x68,
-	0xea, 0xf7, 0x6b, 0xe9, 0x8e, 0xc1, 0xc6, 0x39, 0x0a, 0xa8, 0x8f, 0x24, 0xe3, 0xa7, 0x44, 0xa6,
-	0x63, 0xf5, 0x04, 0xe1, 0x0b, 0x22, 0x85, 0xe9, 0x42, 0x33, 0xa0, 0x42, 0x66, 0x95, 0xf5, 0xe1,
-	0x8d, 0x95, 0x95, 0xec, 0x3a, 0x37, 0x81, 0x1c, 0x22, 0x89, 0xb2, 0x8e, 0xd4, 0x58, 0xf6, 0xcf,
-	0x61, 0xed, 0x33, 0x24, 0x63, 0x4e, 0xfc, 0x5a, 0x8e, 0x57, 0xa1, 0xa1, 0xf2, 0x67, 0xe8, 0xfc,
-	0xa9, 0xa5, 0x9a, 0xf2, 0xd6, 0xc3, 0x2f, 0x23, 0xc6, 0x25, 0xf1, 0xaf, 0xdc, 0xc8, 0x2b, 0xae,
-	0xf7, 0x02, 0xd6, 0xd4, 0x65, 0x09, 0x12, 0xfa, 0x5e, 0x71, 0xce, 0x34, 0x8f, 0xed, 0xbd, 0x5f,
-	0x4d, 0xd5, 0x1d, 0x93, 0xee, 0xb2, 0x03, 0xdc, 0x4e, 0x26, 0xe4, 0xc2, 0xfe, 0xb3, 0x01, 0xd6,
-	0x31, 0x19, 0xef, 0x0b, 0x41, 0x07, 0xe1, 0x88, 0x84, 0x52, 0x31, 0x1b, 0xc2, 0x44, 0x2d, 0xcd,
-	0x77, 0x60, 0xa9, 0x98, 0xa4, 0x7a, 0x80, 0x1a, 0x7a, 0x80, 0x2e, 0xe6, 0x42, 0xd5, 0x60, 0xe6,
-	0x03, 0x80, 0x88, 0x93, 0xc4, 0xc3, 0xde, 0x05, 0x19, 0x67, 0x59, 0xdc, 0xac, 0x0e, 0xc6, 0xf4,
-	0xd7, 0x9f, 0x73, 0x12, 0xf7, 0x03, 0x8a, 0x8f, 0xc9, 0xd8, 0x5d, 0x50, 0xfa, 0xbd, 0x63, 0x32,
-	0x56, 0x2f, 0x9d, 0x88, 0xbd, 0x20, 0x5c, 0x4f, 0xb3, 0x86, 0x9b, 0x7e, 0xd8, 0x7f, 0x31, 0xe0,
-	0x4e, 0x91, 0x8e, 0xbc, 0x5c, 0x4f, 0xe2, 0xbe, 0xb2, 0x78, 0xc5, 0xbd, 0x5d, 0x89, 0x76, 0xf6,
-	0x9a, 0x68, 0x3f, 0x86, 0xc5, 0xa2, 0x41, 0x54, 0xbc, 0x8d, 0x29, 0xe2, 0x6d, 0xe7, 0x16, 0xc7,
-	0x64, 0x6c, 0xff, 0xb1, 0x12, 0xdb, 0xc1, 0xb8, 0xc2, 0x7d, 0xfc, 0x7f, 0xc4, 0x56, 0xb8, 0xad,
-	0xc6, 0x86, 0xab, 0xf6, 0x57, 0x0e, 0xd0, 0xb8, 0x7a, 0x00, 0xfb, 0x6f, 0x06, 0xac, 0x57, 0xbd,
-	0x8a, 0x33, 0x76, 0xc2, 0xe3, 0x90, 0xbc, 0xca, 0x7b, 0xd9, 0x7e, 0xb3, 0xd5, 0xf6, 0x7b, 0x0a,
-	0xcb, 0xb5, 0xa0, 0x44, 0x76, 0x1b, 0xbf, 0x9c, 0xaa, 0xc6, 0x2a, 0xec, 0xea, 0x2e, 0x55, 0xcf,
-	0x21, 0x0e, 0x9e, 0x7e, 0x7b, 0xd9, 0x31, 0xbe, 0xbb, 0xec, 0x18, 0xff, 0xbe, 0xec, 0x18, 0x5f,
-	0xbd, 0xec, 0xcc, 0x7c, 0xf7, 0xb2, 0x33, 0xf3, 0xaf, 0x97, 0x9d, 0x99, 0xdf, 0x7f, 0x34, 0xa0,
-	0x72, 0x18, 0xf7, 0x1d, 0xcc, 0x46, 0xdd, 0xec, 0xa7, 0x7d, 0xe9, 0xeb, 0x83, 0xe2, 0x7f, 0x8f,
-	0xe4, 0x7e, 0xf7, 0xcb, 0xfa, 0xbf, 0x2a, 0x72, 0x1c, 0x11, 0xd1, 0x9f, 0xd7, 0xac, 0x70, 0xff,
-	0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0xa7, 0xa1, 0xa2, 0x88, 0x86, 0x11, 0x00, 0x00,
+	0x11, 0xe6, 0x12, 0x20, 0x45, 0x34, 0xf8, 0xa7, 0x25, 0x65, 0x2d, 0x15, 0x06, 0xa4, 0xd6, 0xb1,
+	0xc3, 0x94, 0xcb, 0x8b, 0x90, 0xaa, 0x54, 0xb9, 0x54, 0x71, 0xb9, 0x48, 0x50, 0xb6, 0x68, 0xc6,
+	0x16, 0xbd, 0x64, 0xa8, 0x4a, 0x72, 0xd8, 0x1a, 0xcc, 0x8e, 0x80, 0x29, 0xee, 0xee, 0xac, 0x66,
+	0x66, 0x57, 0xc2, 0x25, 0xe7, 0x1c, 0x9d, 0x9b, 0x2b, 0x97, 0x38, 0x79, 0x81, 0xbc, 0x86, 0x8f,
+	0x3e, 0xe6, 0x64, 0xa7, 0xa8, 0x43, 0x0e, 0x79, 0x89, 0xd4, 0xcc, 0xfe, 0x02, 0x24, 0x15, 0xa8,
+	0x1c, 0xdf, 0x66, 0x7b, 0xba, 0xbf, 0xee, 0x99, 0xee, 0xfe, 0x7a, 0x00, 0xd8, 0xa3, 0x91, 0x24,
+	0x1c, 0x0f, 0x11, 0x8d, 0x3c, 0x41, 0x70, 0xc2, 0xa9, 0x1c, 0x75, 0x31, 0x4e, 0xbb, 0x31, 0x67,
+	0x29, 0xf5, 0x09, 0xef, 0xa6, 0xbb, 0xe5, 0xda, 0x89, 0x39, 0x93, 0xcc, 0x7c, 0xfb, 0x1a, 0x1b,
+	0x07, 0xe3, 0xd4, 0x29, 0xf5, 0xd2, 0xdd, 0x7b, 0xef, 0xdc, 0x04, 0x9c, 0xee, 0x76, 0x5f, 0x50,
+	0x4e, 0x32, 0xac, 0x7b, 0xeb, 0x03, 0x36, 0x60, 0x7a, 0xd9, 0x55, 0xab, 0x5c, 0xba, 0x35, 0x60,
+	0x6c, 0x10, 0x90, 0xae, 0xfe, 0xea, 0x27, 0xcf, 0xba, 0x92, 0x86, 0x44, 0x48, 0x14, 0xc6, 0xb9,
+	0x42, 0x67, 0x52, 0xc1, 0x4f, 0x38, 0x92, 0x94, 0x45, 0x05, 0x00, 0xed, 0xe3, 0x2e, 0x66, 0x9c,
+	0x74, 0x71, 0x40, 0x49, 0x24, 0x95, 0xd7, 0x6c, 0x95, 0x2b, 0x74, 0x95, 0x42, 0x40, 0x07, 0x43,
+	0x99, 0x89, 0x45, 0x57, 0x92, 0xc8, 0x27, 0x3c, 0xa4, 0x99, 0x72, 0xf5, 0x95, 0x1b, 0x6c, 0xd6,
+	0xf6, 0x31, 0x1f, 0xc5, 0x92, 0x75, 0x2f, 0xc8, 0x48, 0xe4, 0xbb, 0xef, 0x62, 0x26, 0x42, 0x26,
+	0xba, 0x44, 0x9d, 0x3f, 0xc2, 0xa4, 0x9b, 0xee, 0xf6, 0x89, 0x44, 0xbb, 0xa5, 0xa0, 0x88, 0x3b,
+	0xd7, 0xeb, 0x23, 0x51, 0xe9, 0x60, 0x46, 0xf3, 0xb8, 0xed, 0xef, 0xe7, 0xc1, 0xea, 0xb1, 0x48,
+	0x24, 0x21, 0xe1, 0xfb, 0xbe, 0x4f, 0xd5, 0x91, 0x4e, 0x38, 0x8b, 0x99, 0x40, 0x81, 0xb9, 0x0e,
+	0x73, 0x92, 0xca, 0x80, 0x58, 0xc6, 0xb6, 0xb1, 0xd3, 0x72, 0xb3, 0x0f, 0x73, 0x1b, 0xda, 0x3e,
+	0x11, 0x98, 0xd3, 0x58, 0x29, 0x5b, 0xb3, 0x7a, 0xaf, 0x2e, 0x32, 0x37, 0x60, 0x21, 0xcb, 0x03,
+	0xf5, 0xad, 0x86, 0xde, 0xbe, 0xa5, 0xbf, 0x8f, 0x7c, 0xf3, 0x13, 0x58, 0xa6, 0x11, 0x95, 0x14,
+	0x05, 0xde, 0x90, 0xa8, 0xdb, 0xb0, 0x9a, 0xdb, 0xc6, 0x4e, 0x7b, 0xef, 0x9e, 0x43, 0xfb, 0xd8,
+	0x51, 0x17, 0xe8, 0xe4, 0xd7, 0x96, 0xee, 0x3a, 0x8f, 0xb5, 0xc6, 0x41, 0xf3, 0x9b, 0xef, 0xb6,
+	0x66, 0xdc, 0xa5, 0xdc, 0x2e, 0x13, 0x9a, 0xf7, 0x61, 0x71, 0x40, 0x22, 0x22, 0xa8, 0xf0, 0x86,
+	0x48, 0x0c, 0xad, 0xb9, 0x6d, 0x63, 0x67, 0xd1, 0x6d, 0xe7, 0xb2, 0xc7, 0x48, 0x0c, 0xcd, 0x2d,
+	0x68, 0xf7, 0x69, 0x84, 0xf8, 0x28, 0xd3, 0x98, 0xd7, 0x1a, 0x90, 0x89, 0xb4, 0x42, 0x0f, 0x40,
+	0xc4, 0xe8, 0x45, 0xe4, 0xa9, 0x6c, 0x5b, 0xb7, 0xf2, 0x40, 0xb2, 0x4c, 0x3b, 0x45, 0xa6, 0x9d,
+	0xb3, 0xa2, 0x14, 0x0e, 0x16, 0x54, 0x20, 0x5f, 0x7e, 0xbf, 0x65, 0xb8, 0x2d, 0x6d, 0xa7, 0x76,
+	0xcc, 0xcf, 0x61, 0x35, 0x89, 0xfa, 0x2c, 0xf2, 0x69, 0x34, 0xf0, 0x62, 0xc2, 0x29, 0xf3, 0xad,
+	0x05, 0x0d, 0xb5, 0x71, 0x05, 0xea, 0x30, 0x2f, 0x9a, 0x0c, 0xe9, 0x2b, 0x85, 0xb4, 0x52, 0x1a,
+	0x9f, 0x68, 0x5b, 0xf3, 0x0b, 0x30, 0x31, 0x4e, 0x75, 0x48, 0x2c, 0x91, 0x05, 0x62, 0x6b, 0x7a,
+	0xc4, 0x55, 0x8c, 0xd3, 0xb3, 0xcc, 0x3a, 0x87, 0xfc, 0x03, 0xdc, 0x95, 0x1c, 0x45, 0xe2, 0x19,
+	0xe1, 0x93, 0xb8, 0x30, 0x3d, 0xee, 0x9d, 0x02, 0x63, 0x1c, 0xfc, 0x31, 0x6c, 0xe3, 0xbc, 0x80,
+	0x3c, 0x4e, 0x7c, 0x2a, 0x24, 0xa7, 0xfd, 0x44, 0xd9, 0x7a, 0xcf, 0x38, 0xc2, 0xba, 0x46, 0xda,
+	0xba, 0x08, 0x3a, 0x85, 0x9e, 0x3b, 0xa6, 0xf6, 0x71, 0xae, 0x65, 0x3e, 0x81, 0x9f, 0xf5, 0x03,
+	0x86, 0x2f, 0x84, 0x0a, 0xce, 0x1b, 0x43, 0xd2, 0xae, 0x43, 0x2a, 0x84, 0x42, 0x5b, 0xdc, 0x36,
+	0x76, 0x1a, 0xee, 0xfd, 0x4c, 0xf7, 0x84, 0xf0, 0xc3, 0x9a, 0xe6, 0x59, 0x4d, 0xd1, 0x7c, 0x1f,
+	0xcc, 0x21, 0x15, 0x92, 0x71, 0x8a, 0x51, 0xe0, 0x91, 0x48, 0x72, 0x4a, 0x84, 0xb5, 0xa4, 0xcd,
+	0x6f, 0x57, 0x3b, 0x8f, 0xb2, 0x0d, 0xf3, 0x53, 0xb8, 0x7f, 0xa3, 0x53, 0x0f, 0x0f, 0x51, 0x14,
+	0x91, 0xc0, 0x5a, 0xd6, 0x47, 0xd9, 0xf2, 0x6f, 0xf0, 0xd9, 0xcb, 0xd4, 0x1e, 0x2e, 0xfc, 0xe9,
+	0xeb, 0xad, 0x99, 0xaf, 0xbe, 0xde, 0x9a, 0xb1, 0xff, 0x61, 0xc0, 0xdd, 0x5e, 0x79, 0xf0, 0x90,
+	0xa5, 0x28, 0xf8, 0x31, 0x1b, 0x6c, 0x1f, 0x5a, 0x42, 0xb2, 0x38, 0x2b, 0xe9, 0xe6, 0x1b, 0x94,
+	0xf4, 0x82, 0x32, 0x53, 0x1b, 0xf6, 0x5f, 0x0d, 0x58, 0x7f, 0xf4, 0x3c, 0xa1, 0x29, 0xc3, 0xe8,
+	0xff, 0xc2, 0x07, 0xc7, 0xb0, 0x44, 0x6a, 0x78, 0xc2, 0x6a, 0x6c, 0x37, 0x76, 0xda, 0x7b, 0xef,
+	0x38, 0x19, 0x39, 0x39, 0x25, 0x67, 0xe5, 0x04, 0xe5, 0xd4, 0xbd, 0xbb, 0xe3, 0xb6, 0x0f, 0x67,
+	0x2d, 0xc3, 0xfe, 0xbb, 0x01, 0xf7, 0xd4, 0x4d, 0x0f, 0x88, 0x4b, 0x5e, 0x20, 0xee, 0x1f, 0x92,
+	0x88, 0x85, 0xe2, 0x07, 0xc7, 0x69, 0xc3, 0x92, 0xaf, 0x91, 0x3c, 0xc9, 0x3c, 0xe4, 0xfb, 0x3a,
+	0x4e, 0xad, 0xa3, 0x84, 0x67, 0x6c, 0xdf, 0xf7, 0xcd, 0x1d, 0x58, 0xad, 0x74, 0xb8, 0xca, 0xa7,
+	0xba, 0x66, 0xa5, 0xb6, 0x5c, 0xa8, 0xe9, 0x2c, 0x13, 0xfb, 0x3f, 0x06, 0xac, 0x7e, 0x12, 0xb0,
+	0x3e, 0x0a, 0x4e, 0x03, 0x24, 0x86, 0xaa, 0xca, 0x46, 0x2a, 0x3d, 0x9c, 0xe4, 0xed, 0xad, 0xc3,
+	0x9b, 0x3a, 0x3d, 0xca, 0x4c, 0x13, 0xce, 0x47, 0x70, 0xbb, 0x6c, 0xb8, 0xb2, 0x0a, 0xf4, 0x69,
+	0x0e, 0xd6, 0x2e, 0xbf, 0xdb, 0x5a, 0x29, 0x8a, 0xad, 0xa7, 0x2b, 0xe2, 0xd0, 0x5d, 0xc1, 0x63,
+	0x02, 0xdf, 0xec, 0x40, 0x9b, 0xf6, 0xb1, 0x27, 0xc8, 0x73, 0x2f, 0x4a, 0x42, 0x5d, 0x40, 0x4d,
+	0xb7, 0x45, 0xfb, 0xf8, 0x94, 0x3c, 0xff, 0x3c, 0x09, 0xcd, 0x07, 0xf0, 0x56, 0x31, 0x58, 0xbd,
+	0x14, 0x05, 0x9e, 0xb2, 0x57, 0xd7, 0xc1, 0x75, 0x3d, 0x2d, 0xba, 0x6b, 0xc5, 0xee, 0x39, 0x0a,
+	0x94, 0xb3, 0x7d, 0xdf, 0xe7, 0xf6, 0xbf, 0xe7, 0x60, 0xfe, 0x04, 0x71, 0x14, 0x0a, 0xf3, 0x0c,
+	0x56, 0x24, 0x09, 0xe3, 0x00, 0x49, 0xe2, 0x65, 0x64, 0x9e, 0x9f, 0xf4, 0x3d, 0x4d, 0xf2, 0xf5,
+	0x21, 0xe8, 0xd4, 0xc6, 0x5e, 0xba, 0xeb, 0xf4, 0xb4, 0xf4, 0x54, 0x22, 0x49, 0xdc, 0xe5, 0x02,
+	0x23, 0x13, 0x9a, 0x1f, 0x80, 0x25, 0x79, 0x22, 0x64, 0x45, 0xb3, 0x15, 0xbf, 0x64, 0xb9, 0x7c,
+	0xab, 0xd8, 0xcf, 0x98, 0xa9, 0xe4, 0x95, 0xeb, 0x19, 0xb5, 0xf1, 0x43, 0x18, 0xf5, 0x14, 0xd6,
+	0xd4, 0x38, 0x9a, 0xc4, 0x6c, 0x4e, 0x8f, 0x79, 0x5b, 0xd9, 0x8f, 0x83, 0x7e, 0x01, 0x66, 0x2a,
+	0xf0, 0x24, 0xe6, 0xdc, 0x1b, 0xc4, 0x99, 0x0a, 0x3c, 0x0e, 0xe9, 0xc3, 0xa6, 0x50, 0xc5, 0xe7,
+	0x85, 0x44, 0x6a, 0x7e, 0x8e, 0x03, 0x12, 0x51, 0x31, 0x2c, 0xc0, 0xe7, 0xa7, 0x07, 0xdf, 0xd0,
+	0x40, 0x9f, 0x29, 0x1c, 0xb7, 0x80, 0xc9, 0xbd, 0xf4, 0xa0, 0x73, 0xbd, 0x97, 0x32, 0x41, 0xb7,
+	0x74, 0x82, 0x7e, 0x72, 0x0d, 0x44, 0x99, 0xa5, 0x3d, 0xb8, 0x13, 0xa2, 0x97, 0x9e, 0x1c, 0x72,
+	0x26, 0x65, 0x40, 0x7c, 0x2f, 0x46, 0xf8, 0x82, 0x48, 0xa1, 0x87, 0x69, 0xc3, 0x5d, 0x0b, 0xd1,
+	0xcb, 0xb3, 0x62, 0xef, 0x24, 0xdb, 0x32, 0x05, 0xbc, 0x5b, 0x9b, 0x3d, 0x8a, 0x09, 0x3c, 0xdd,
+	0x84, 0x1e, 0x27, 0x03, 0x45, 0xd0, 0x28, 0x1b, 0x43, 0x84, 0x94, 0xf3, 0x33, 0x67, 0x1c, 0xf5,
+	0x1c, 0x2a, 0xd9, 0xa6, 0xc7, 0x68, 0x94, 0x3f, 0x32, 0xec, 0x6a, 0x44, 0x95, 0xbc, 0xe2, 0xd6,
+	0xb0, 0x3e, 0x26, 0xc4, 0xfe, 0x05, 0xb4, 0x74, 0x43, 0xef, 0xe3, 0x0b, 0x61, 0x6e, 0x42, 0x4b,
+	0x75, 0x06, 0x11, 0x82, 0x08, 0xcb, 0xd0, 0x3c, 0x50, 0x09, 0x6c, 0x09, 0x1b, 0x37, 0x3d, 0xae,
+	0x84, 0xf9, 0x14, 0x6e, 0xc5, 0x44, 0x4f, 0x7e, 0x6d, 0xd8, 0xde, 0xfb, 0xd0, 0x99, 0xe2, 0x9d,
+	0xeb, 0xdc, 0x04, 0xe8, 0x16, 0x68, 0x36, 0xaf, 0x9e, 0x74, 0x13, 0x03, 0x47, 0x98, 0xe7, 0x93,
+	0x4e, 0x7f, 0xfd, 0x46, 0x4e, 0x27, 0xf0, 0x2a, 0x9f, 0xef, 0x41, 0x7b, 0x3f, 0x3b, 0xf6, 0x6f,
+	0xa8, 0x90, 0x57, 0xaf, 0x65, 0xb1, 0x7e, 0x2d, 0x9f, 0xc2, 0x72, 0x3e, 0x27, 0xcf, 0x98, 0x26,
+	0x25, 0xf3, 0xa7, 0x00, 0xf9, 0x80, 0x55, 0x64, 0x96, 0xd1, 0x76, 0x2b, 0x97, 0x1c, 0xf9, 0x63,
+	0xf3, 0x6e, 0x76, 0x6c, 0xde, 0xd9, 0x2e, 0xac, 0x9c, 0x0b, 0xfc, 0xdb, 0xe2, 0x11, 0xf5, 0x24,
+	0x16, 0xe6, 0x1d, 0x98, 0x57, 0x7d, 0x94, 0x03, 0x35, 0xdd, 0xb9, 0x54, 0xe0, 0x23, 0xcd, 0xdc,
+	0xd5, 0x43, 0x8d, 0xc5, 0x1e, 0xf5, 0x85, 0x35, 0xbb, 0xdd, 0xd8, 0x69, 0xba, 0xcb, 0x49, 0x65,
+	0x7e, 0xe4, 0x0b, 0xfb, 0x77, 0xd0, 0xae, 0x01, 0x9a, 0xcb, 0x30, 0x5b, 0x62, 0xcd, 0x52, 0xdf,
+	0x7c, 0x08, 0x1b, 0x15, 0xd0, 0x38, 0x15, 0x67, 0x88, 0x2d, 0xf7, 0x6e, 0xa9, 0x30, 0xc6, 0xc6,
+	0xc2, 0x7e, 0x02, 0xeb, 0x47, 0x55, 0xe3, 0x97, 0x44, 0x3f, 0x76, 0x42, 0x63, 0x7c, 0xa2, 0x6f,
+	0x42, 0xab, 0xfc, 0x35, 0xa2, 0x4f, 0xdf, 0x74, 0x2b, 0x81, 0x1d, 0xc2, 0xea, 0xb9, 0xc0, 0xa7,
+	0x24, 0xf2, 0x2b, 0xb0, 0x1b, 0x2e, 0xe0, 0x60, 0x12, 0x68, 0xea, 0xd7, 0x6e, 0xe5, 0x8e, 0xc1,
+	0xc6, 0x39, 0x0a, 0xa8, 0x8f, 0x24, 0xe3, 0xa7, 0x44, 0x66, 0x43, 0xb8, 0x68, 0x47, 0x17, 0x9a,
+	0x01, 0x15, 0x32, 0xaf, 0xac, 0x0f, 0x6e, 0xac, 0xac, 0x74, 0xd7, 0xb9, 0x09, 0xe4, 0x10, 0x49,
+	0x94, 0xf7, 0xa2, 0xc6, 0xb2, 0x7f, 0x0e, 0x6b, 0x9f, 0x21, 0x99, 0x70, 0xe2, 0x8f, 0xe5, 0x78,
+	0x15, 0x1a, 0x2a, 0x7f, 0x86, 0xce, 0x9f, 0x5a, 0xaa, 0x37, 0x81, 0xf5, 0xe8, 0x65, 0xcc, 0xb8,
+	0x24, 0xfe, 0x95, 0x1b, 0x79, 0xcd, 0xf5, 0x5e, 0xc0, 0x9a, 0xba, 0x2c, 0x41, 0x22, 0xdf, 0x2b,
+	0xcf, 0x99, 0xe5, 0xb1, 0xbd, 0xf7, 0xab, 0xa9, 0xba, 0x63, 0xd2, 0x5d, 0x7e, 0x80, 0xdb, 0xe9,
+	0x84, 0x5c, 0xd8, 0x7f, 0x36, 0xc0, 0x3a, 0x26, 0xa3, 0x7d, 0x21, 0xe8, 0x20, 0x0a, 0x49, 0x24,
+	0x15, 0x0f, 0x22, 0x4c, 0xd4, 0xd2, 0x7c, 0x1b, 0x96, 0xca, 0xb9, 0xab, 0xc7, 0xad, 0xa1, 0xc7,
+	0xed, 0x62, 0x21, 0x54, 0x0d, 0x66, 0x3e, 0x04, 0x88, 0x39, 0x49, 0x3d, 0xec, 0x5d, 0x90, 0x51,
+	0x9e, 0xc5, 0xcd, 0xfa, 0x18, 0xcd, 0x7e, 0x2b, 0x3a, 0x27, 0x49, 0x3f, 0xa0, 0xf8, 0x98, 0x8c,
+	0xdc, 0x05, 0xa5, 0xdf, 0x3b, 0x26, 0x23, 0xf5, 0x2e, 0x8a, 0xd9, 0x0b, 0xc2, 0xf5, 0xec, 0x6b,
+	0xb8, 0xd9, 0x87, 0xfd, 0x17, 0x03, 0xee, 0x96, 0xe9, 0x28, 0xca, 0xf5, 0x24, 0xe9, 0x2b, 0x8b,
+	0xd7, 0xdc, 0xdb, 0x95, 0x68, 0x67, 0xaf, 0x89, 0xf6, 0x23, 0x58, 0x2c, 0x1b, 0x44, 0xc5, 0xdb,
+	0x98, 0x22, 0xde, 0x76, 0x61, 0x71, 0x4c, 0x46, 0xf6, 0x1f, 0x6b, 0xb1, 0x1d, 0x8c, 0x6a, 0xdc,
+	0xc7, 0xff, 0x47, 0x6c, 0xa5, 0xdb, 0x7a, 0x6c, 0xb8, 0x6e, 0x7f, 0xe5, 0x00, 0x8d, 0xab, 0x07,
+	0xb0, 0xff, 0x66, 0xc0, 0x7a, 0xdd, 0xab, 0x38, 0x63, 0x27, 0x3c, 0x89, 0xc8, 0xeb, 0xbc, 0x57,
+	0xed, 0x37, 0x5b, 0x6f, 0xbf, 0xa7, 0xb0, 0x3c, 0x16, 0x94, 0xc8, 0x6f, 0xe3, 0x97, 0x53, 0xd5,
+	0x58, 0x8d, 0x5d, 0xdd, 0xa5, 0xfa, 0x39, 0xc4, 0xc1, 0xd3, 0x6f, 0x2e, 0x3b, 0xc6, 0xb7, 0x97,
+	0x1d, 0xe3, 0x5f, 0x97, 0x1d, 0xe3, 0xcb, 0x57, 0x9d, 0x99, 0x6f, 0x5f, 0x75, 0x66, 0xfe, 0xf9,
+	0xaa, 0x33, 0xf3, 0xfb, 0x0f, 0x07, 0x54, 0x0e, 0x93, 0xbe, 0x83, 0x59, 0xd8, 0xcd, 0xff, 0x08,
+	0xa8, 0x7c, 0xbd, 0x5f, 0xfe, 0x4b, 0x92, 0x3e, 0xe8, 0xbe, 0x1c, 0xff, 0x0f, 0x46, 0x8e, 0x62,
+	0x22, 0xfa, 0xf3, 0x9a, 0x15, 0x1e, 0xfc, 0x37, 0x00, 0x00, 0xff, 0xff, 0x10, 0x72, 0xcb, 0xcf,
+	0xb4, 0x11, 0x00, 0x00,
 }
 
 func (m *ConsumerAdditionProposal) Marshal() (dAtA []byte, err error) {
diff --git a/x/ccv/provider/types/query.pb.go b/x/ccv/provider/types/query.pb.go
index afb2802eb1..66a422a31e 100644
--- a/x/ccv/provider/types/query.pb.go
+++ b/x/ccv/provider/types/query.pb.go
@@ -1047,7 +1047,7 @@ func (m *QueryProposedChainIDsRequest) Reset()         { *m = QueryProposedChain
 func (m *QueryProposedChainIDsRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryProposedChainIDsRequest) ProtoMessage()    {}
 func (*QueryProposedChainIDsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_422512d7b7586cd7, []int{17}
+	return fileDescriptor_422512d7b7586cd7, []int{21}
 }
 func (m *QueryProposedChainIDsRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1084,7 +1084,7 @@ func (m *QueryProposedChainIDsResponse) Reset()         { *m = QueryProposedChai
 func (m *QueryProposedChainIDsResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryProposedChainIDsResponse) ProtoMessage()    {}
 func (*QueryProposedChainIDsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_422512d7b7586cd7, []int{18}
+	return fileDescriptor_422512d7b7586cd7, []int{22}
 }
 func (m *QueryProposedChainIDsResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1129,7 +1129,7 @@ func (m *ProposedChain) Reset()         { *m = ProposedChain{} }
 func (m *ProposedChain) String() string { return proto.CompactTextString(m) }
 func (*ProposedChain) ProtoMessage()    {}
 func (*ProposedChain) Descriptor() ([]byte, []int) {
-	return fileDescriptor_422512d7b7586cd7, []int{19}
+	return fileDescriptor_422512d7b7586cd7, []int{23}
 }
 func (m *ProposedChain) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1185,7 +1185,7 @@ func (m *QueryAllPairsValConAddrByConsumerChainIDRequest) String() string {
 }
 func (*QueryAllPairsValConAddrByConsumerChainIDRequest) ProtoMessage() {}
 func (*QueryAllPairsValConAddrByConsumerChainIDRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_422512d7b7586cd7, []int{20}
+	return fileDescriptor_422512d7b7586cd7, []int{24}
 }
 func (m *QueryAllPairsValConAddrByConsumerChainIDRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1233,7 +1233,7 @@ func (m *QueryAllPairsValConAddrByConsumerChainIDResponse) String() string {
 }
 func (*QueryAllPairsValConAddrByConsumerChainIDResponse) ProtoMessage() {}
 func (*QueryAllPairsValConAddrByConsumerChainIDResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_422512d7b7586cd7, []int{21}
+	return fileDescriptor_422512d7b7586cd7, []int{25}
 }
 func (m *QueryAllPairsValConAddrByConsumerChainIDResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1281,7 +1281,7 @@ func (m *PairValConAddrProviderAndConsumer) Reset()         { *m = PairValConAdd
 func (m *PairValConAddrProviderAndConsumer) String() string { return proto.CompactTextString(m) }
 func (*PairValConAddrProviderAndConsumer) ProtoMessage()    {}
 func (*PairValConAddrProviderAndConsumer) Descriptor() ([]byte, []int) {
-	return fileDescriptor_422512d7b7586cd7, []int{22}
+	return fileDescriptor_422512d7b7586cd7, []int{26}
 }
 func (m *PairValConAddrProviderAndConsumer) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1331,6 +1331,86 @@ func (m *PairValConAddrProviderAndConsumer) GetConsumerKey() *crypto.PublicKey {
 	return nil
 }
 
+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_422512d7b7586cd7, []int{27}
+}
+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
+
+type QueryParamsResponse struct {
+	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_422512d7b7586cd7, []int{28}
+}
+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{}
+}
+
 func init() {
 	proto.RegisterType((*QueryConsumerGenesisRequest)(nil), "interchain_security.ccv.provider.v1.QueryConsumerGenesisRequest")
 	proto.RegisterType((*QueryConsumerGenesisResponse)(nil), "interchain_security.ccv.provider.v1.QueryConsumerGenesisResponse")
@@ -1359,6 +1439,8 @@ func init() {
 	proto.RegisterType((*QueryAllPairsValConAddrByConsumerChainIDRequest)(nil), "interchain_security.ccv.provider.v1.QueryAllPairsValConAddrByConsumerChainIDRequest")
 	proto.RegisterType((*QueryAllPairsValConAddrByConsumerChainIDResponse)(nil), "interchain_security.ccv.provider.v1.QueryAllPairsValConAddrByConsumerChainIDResponse")
 	proto.RegisterType((*PairValConAddrProviderAndConsumer)(nil), "interchain_security.ccv.provider.v1.PairValConAddrProviderAndConsumer")
+	proto.RegisterType((*QueryParamsRequest)(nil), "interchain_security.ccv.provider.v1.QueryParamsRequest")
+	proto.RegisterType((*QueryParamsResponse)(nil), "interchain_security.ccv.provider.v1.QueryParamsResponse")
 }
 
 func init() {
@@ -1366,91 +1448,111 @@ func init() {
 }
 
 var fileDescriptor_422512d7b7586cd7 = []byte{
-	// 1336 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0xcf, 0x6f, 0xdc, 0x44,
-	0x14, 0x8e, 0x93, 0xb6, 0x24, 0x93, 0xfe, 0x62, 0x5a, 0x4a, 0xea, 0x86, 0xdd, 0xd6, 0x15, 0x90,
-	0x16, 0xb0, 0x93, 0x8d, 0x90, 0xfa, 0x83, 0x34, 0xdd, 0x4d, 0xda, 0x12, 0xa5, 0x55, 0x83, 0x5b,
-	0x8a, 0x04, 0x08, 0x33, 0xb1, 0x87, 0x8d, 0x55, 0xaf, 0xc7, 0x9d, 0x99, 0xdd, 0x76, 0x55, 0x71,
-	0x28, 0x07, 0xe8, 0xb1, 0x12, 0x70, 0xe1, 0xd4, 0x0b, 0xff, 0x4b, 0x6f, 0x14, 0xf5, 0xc2, 0xa9,
-	0xa0, 0x84, 0x03, 0xe2, 0x84, 0xb8, 0x23, 0x21, 0x8f, 0xc7, 0xde, 0xf5, 0xae, 0xb3, 0xeb, 0xdd,
-	0xe4, 0xb6, 0x3b, 0xf3, 0xde, 0xf7, 0xde, 0xf7, 0xe6, 0xcd, 0x9b, 0xcf, 0xc0, 0x70, 0x7d, 0x8e,
-	0xa9, 0xbd, 0x81, 0x5c, 0xdf, 0x62, 0xd8, 0xae, 0x53, 0x97, 0x37, 0x0d, 0xdb, 0x6e, 0x18, 0x01,
-	0x25, 0x0d, 0xd7, 0xc1, 0xd4, 0x68, 0xcc, 0x19, 0xf7, 0xea, 0x98, 0x36, 0xf5, 0x80, 0x12, 0x4e,
-	0xe0, 0xe9, 0x0c, 0x07, 0xdd, 0xb6, 0x1b, 0x7a, 0xec, 0xa0, 0x37, 0xe6, 0xd4, 0xe9, 0x2a, 0x21,
-	0x55, 0x0f, 0x1b, 0x28, 0x70, 0x0d, 0xe4, 0xfb, 0x84, 0x23, 0xee, 0x12, 0x9f, 0x45, 0x10, 0xea,
-	0xd1, 0x2a, 0xa9, 0x12, 0xf1, 0xd3, 0x08, 0x7f, 0xc9, 0xd5, 0xa2, 0xf4, 0x11, 0xff, 0xd6, 0xeb,
-	0x5f, 0x19, 0xdc, 0xad, 0x61, 0xc6, 0x51, 0x2d, 0x90, 0x06, 0xa5, 0x3c, 0xa9, 0x26, 0x59, 0x44,
-	0x3e, 0xb3, 0xdb, 0xf9, 0x34, 0xe6, 0x0c, 0xb6, 0x81, 0x28, 0x76, 0x2c, 0x9b, 0xf8, 0xac, 0x5e,
-	0x4b, 0x3c, 0xde, 0xec, 0xe1, 0x71, 0xdf, 0xa5, 0x58, 0x9a, 0x4d, 0x73, 0xec, 0x3b, 0x98, 0xd6,
-	0x5c, 0x9f, 0x1b, 0x36, 0x6d, 0x06, 0x9c, 0x18, 0x77, 0x71, 0x53, 0x32, 0xd4, 0xce, 0x81, 0x13,
-	0x1f, 0x85, 0x35, 0x5b, 0x92, 0xd8, 0xd7, 0xb0, 0x8f, 0x99, 0xcb, 0x4c, 0x7c, 0xaf, 0x8e, 0x19,
-	0x87, 0xc7, 0xc1, 0x78, 0x14, 0xc0, 0x75, 0xa6, 0x94, 0x93, 0xca, 0xcc, 0x84, 0xf9, 0x8a, 0xf8,
-	0xbf, 0xe2, 0x68, 0x0f, 0xc1, 0x74, 0xb6, 0x27, 0x0b, 0x88, 0xcf, 0x30, 0xfc, 0x0c, 0x1c, 0xa8,
-	0x46, 0x4b, 0x16, 0xe3, 0x88, 0x63, 0xe1, 0x3f, 0x59, 0x9a, 0xd5, 0xb7, 0x3b, 0x96, 0xc6, 0x9c,
-	0xde, 0x81, 0x75, 0x2b, 0xf4, 0xab, 0xec, 0x79, 0xf6, 0xb2, 0x38, 0x62, 0xee, 0xaf, 0xb6, 0xad,
-	0x69, 0xd3, 0x40, 0x4d, 0x05, 0x5f, 0x0a, 0xe1, 0xe2, 0xac, 0x35, 0xd4, 0x41, 0x2a, 0xde, 0x95,
-	0x99, 0x55, 0xc0, 0x3e, 0x11, 0x9e, 0x4d, 0x29, 0x27, 0xc7, 0x66, 0x26, 0x4b, 0x67, 0xf5, 0x1c,
-	0x9d, 0xa2, 0x0b, 0x10, 0x53, 0x7a, 0x6a, 0x67, 0xc0, 0xdb, 0xdd, 0x21, 0x6e, 0x71, 0x44, 0xf9,
-	0x1a, 0x25, 0x01, 0x61, 0xc8, 0x4b, 0xb2, 0x79, 0xac, 0x80, 0x99, 0xfe, 0xb6, 0x32, 0xb7, 0xcf,
-	0xc1, 0x44, 0x10, 0x2f, 0xca, 0x8a, 0x5d, 0xca, 0x97, 0x9e, 0x04, 0x2f, 0x3b, 0x8e, 0x1b, 0xb6,
-	0x70, 0x0b, 0xba, 0x05, 0xa8, 0xcd, 0x80, 0xb7, 0xb2, 0x32, 0x21, 0x41, 0x57, 0xd2, 0xdf, 0x2a,
-	0xd9, 0x04, 0x53, 0xa6, 0xc9, 0x49, 0x77, 0xe5, 0xbc, 0x30, 0x50, 0xce, 0x26, 0xae, 0x91, 0x06,
-	0xf2, 0x32, 0x53, 0x5e, 0x04, 0x7b, 0x45, 0xe8, 0x1e, 0xad, 0x08, 0x4f, 0x80, 0x09, 0xdb, 0x73,
-	0xb1, 0xcf, 0xc3, 0xbd, 0x51, 0xb1, 0x37, 0x1e, 0x2d, 0xac, 0x38, 0xda, 0x77, 0x0a, 0x38, 0x25,
-	0x98, 0xdc, 0x41, 0x9e, 0xeb, 0x20, 0x4e, 0x68, 0x5b, 0xa9, 0x68, 0xff, 0x46, 0x87, 0x0b, 0xe0,
-	0x70, 0x9c, 0xb4, 0x85, 0x1c, 0x87, 0x62, 0xc6, 0xa2, 0x20, 0x15, 0xf8, 0xef, 0xcb, 0xe2, 0xc1,
-	0x26, 0xaa, 0x79, 0x17, 0x34, 0xb9, 0xa1, 0x99, 0x87, 0x62, 0xdb, 0x72, 0xb4, 0x72, 0x61, 0xfc,
-	0xf1, 0xd3, 0xe2, 0xc8, 0x5f, 0x4f, 0x8b, 0x23, 0xda, 0x4d, 0xa0, 0xf5, 0x4a, 0x44, 0x56, 0xf3,
-	0x0c, 0x38, 0x1c, 0x5f, 0xf4, 0x24, 0x5c, 0x94, 0xd1, 0x21, 0xbb, 0xcd, 0x3e, 0x0c, 0xd6, 0x4d,
-	0x6d, 0xad, 0x2d, 0x78, 0x3e, 0x6a, 0x5d, 0xb1, 0x7a, 0x50, 0xeb, 0x88, 0xdf, 0x8b, 0x5a, 0x3a,
-	0x91, 0x16, 0xb5, 0xae, 0x4a, 0x4a, 0x6a, 0x1d, 0x55, 0xd3, 0x4e, 0x80, 0xe3, 0x02, 0xf0, 0xf6,
-	0x06, 0x25, 0x9c, 0x7b, 0x58, 0x5c, 0xfb, 0xb8, 0x39, 0x7f, 0x55, 0xe4, 0xf5, 0xef, 0xd8, 0x95,
-	0x61, 0x8a, 0x60, 0x92, 0x79, 0x88, 0x6d, 0x58, 0x35, 0xcc, 0x31, 0x15, 0x11, 0xc6, 0x4c, 0x20,
-	0x96, 0x6e, 0x84, 0x2b, 0xb0, 0x04, 0x5e, 0x6b, 0x33, 0xb0, 0x90, 0xe7, 0x91, 0xfb, 0xc8, 0xb7,
-	0xb1, 0xe0, 0x3e, 0x66, 0x1e, 0x69, 0x99, 0x96, 0xe3, 0x2d, 0xf8, 0x05, 0x98, 0xf2, 0xf1, 0x03,
-	0x6e, 0x51, 0x1c, 0x78, 0xd8, 0x77, 0xd9, 0x86, 0x65, 0x23, 0xdf, 0x09, 0xc9, 0xe2, 0xa9, 0x31,
-	0xd1, 0xf3, 0xaa, 0x1e, 0xbd, 0x0b, 0x7a, 0xfc, 0x2e, 0xe8, 0xb7, 0xe3, 0x77, 0xa1, 0x32, 0x1e,
-	0xce, 0xb0, 0x27, 0xbf, 0x17, 0x15, 0xf3, 0x58, 0x88, 0x62, 0xc6, 0x20, 0x4b, 0x31, 0x86, 0xf6,
-	0x2e, 0x38, 0x2b, 0x28, 0x99, 0xb8, 0xea, 0x32, 0x8e, 0x29, 0x76, 0x5a, 0xb7, 0xe3, 0x3e, 0xa2,
-	0xce, 0x32, 0xf6, 0x49, 0x2d, 0xb9, 0x9e, 0x57, 0xc0, 0x3b, 0xb9, 0xac, 0x65, 0x45, 0x8e, 0x81,
-	0x7d, 0x8e, 0x58, 0x11, 0x13, 0x6f, 0xc2, 0x94, 0xff, 0xb4, 0x82, 0x9c, 0xe1, 0xd1, 0xcd, 0xc3,
-	0x8e, 0xb8, 0x69, 0x2b, 0xcb, 0x49, 0x98, 0x47, 0x0a, 0x78, 0x63, 0x1b, 0x03, 0x89, 0xfc, 0x25,
-	0x38, 0x18, 0xb4, 0xef, 0xc5, 0x33, 0xb5, 0x94, 0x6b, 0x00, 0xa4, 0x60, 0xe5, 0xa0, 0xef, 0xc0,
-	0xd3, 0x56, 0xc0, 0x81, 0x94, 0x19, 0x9c, 0x02, 0xb2, 0x7f, 0x97, 0xd3, 0xed, 0xbc, 0x0c, 0x0b,
-	0x00, 0xc4, 0x83, 0x63, 0x65, 0x59, 0x1c, 0xe6, 0x1e, 0xb3, 0x6d, 0x45, 0xbb, 0x0e, 0x0c, 0xc1,
-	0xa6, 0xec, 0x79, 0x6b, 0xc8, 0xa5, 0xec, 0x0e, 0xf2, 0x96, 0x88, 0x1f, 0xb6, 0x5c, 0x25, 0x3d,
-	0xe7, 0x56, 0x96, 0x73, 0x3c, 0x80, 0x3f, 0x2b, 0x60, 0x36, 0x3f, 0x9c, 0xac, 0xd7, 0x3d, 0xf0,
-	0x6a, 0x80, 0x5c, 0x6a, 0x35, 0x90, 0x17, 0xbe, 0xe7, 0xe2, 0x1a, 0xc8, 0x92, 0x5d, 0xcd, 0x57,
-	0x32, 0xe4, 0xd2, 0x56, 0xa0, 0xe4, 0x9a, 0xf9, 0xad, 0x06, 0x38, 0x18, 0xa4, 0x4c, 0xb4, 0x4d,
-	0x05, 0x9c, 0xea, 0xeb, 0x95, 0x39, 0xe5, 0x94, 0xdc, 0x53, 0x6e, 0x87, 0x93, 0x04, 0x2e, 0x82,
-	0xfd, 0x89, 0xfb, 0x5d, 0xdc, 0x94, 0x37, 0x6a, 0x5a, 0x6f, 0x69, 0x17, 0x3d, 0xd2, 0x2e, 0xfa,
-	0x5a, 0x7d, 0xdd, 0x73, 0xed, 0x55, 0xdc, 0x34, 0x27, 0x63, 0x8f, 0x55, 0xdc, 0x2c, 0xfd, 0x74,
-	0x04, 0xec, 0x15, 0x87, 0x01, 0x37, 0x15, 0x70, 0x34, 0x4b, 0x98, 0xc0, 0xcb, 0xb9, 0xea, 0xdb,
-	0x43, 0x0d, 0xa9, 0xe5, 0x1d, 0x20, 0x44, 0xe7, 0xaf, 0x5d, 0xf9, 0xe6, 0xc5, 0x9f, 0xdf, 0x8f,
-	0x2e, 0xc2, 0x85, 0xfe, 0x72, 0x36, 0x29, 0x88, 0x54, 0x3e, 0xc6, 0xc3, 0xb8, 0x13, 0xbf, 0x86,
-	0x2f, 0x14, 0x70, 0x24, 0x43, 0xe2, 0xc0, 0xc5, 0xc1, 0x33, 0x4c, 0x49, 0x27, 0xf5, 0xf2, 0xf0,
-	0x00, 0x92, 0xe1, 0x79, 0xc1, 0x70, 0x1e, 0xce, 0x0d, 0xc0, 0x30, 0x12, 0x55, 0xf0, 0xd1, 0x28,
-	0x98, 0xda, 0x46, 0x29, 0x31, 0x78, 0x7d, 0xc8, 0xcc, 0x32, 0x45, 0x99, 0x7a, 0x63, 0x97, 0xd0,
-	0x24, 0xe9, 0x0f, 0x05, 0xe9, 0x0a, 0xbc, 0x3c, 0x28, 0xe9, 0x50, 0x1b, 0x53, 0x6e, 0x25, 0x7a,
-	0x07, 0xfe, 0xa7, 0x80, 0xd7, 0xb3, 0x85, 0x17, 0x83, 0xab, 0x43, 0x27, 0xdd, 0xad, 0xf0, 0xd4,
-	0xeb, 0xbb, 0x03, 0x26, 0x0b, 0x70, 0x4d, 0x14, 0xa0, 0x0c, 0x17, 0x87, 0x28, 0x00, 0x09, 0xda,
-	0xf8, 0xff, 0x13, 0xbf, 0xed, 0x99, 0x2a, 0x09, 0x5e, 0xcd, 0x9f, 0x75, 0x2f, 0xbd, 0xa7, 0x5e,
-	0xdb, 0x31, 0x8e, 0x24, 0x5e, 0x16, 0xc4, 0x2f, 0xc2, 0xf3, 0x39, 0xbe, 0x4f, 0x63, 0x20, 0x2b,
-	0x35, 0x2a, 0x33, 0x28, 0xb7, 0xab, 0xa7, 0xa1, 0x28, 0x67, 0xe8, 0xc0, 0xa1, 0x28, 0x67, 0xc9,
-	0xb8, 0xe1, 0x28, 0xa7, 0x1e, 0x17, 0xf8, 0x8b, 0x02, 0x60, 0xb7, 0x82, 0x83, 0x97, 0xf2, 0xa7,
-	0x98, 0x25, 0x0c, 0xd5, 0xc5, 0xa1, 0xfd, 0x25, 0xb5, 0x73, 0x82, 0x5a, 0x09, 0xce, 0xf6, 0xa7,
-	0xc6, 0x25, 0x40, 0xf4, 0x75, 0x0b, 0x7f, 0x1c, 0x05, 0xa7, 0x73, 0x48, 0x32, 0x78, 0x33, 0x7f,
-	0x8a, 0xb9, 0xa4, 0xa0, 0xba, 0xb6, 0x7b, 0x80, 0xb2, 0x08, 0xab, 0xa2, 0x08, 0x57, 0xe0, 0x52,
-	0xff, 0x22, 0xd0, 0x04, 0xb1, 0xd5, 0xd3, 0x54, 0x60, 0x5a, 0x91, 0xc4, 0x84, 0x7f, 0x77, 0x49,
-	0xc8, 0xb4, 0x32, 0x62, 0x70, 0x80, 0x57, 0x75, 0x1b, 0x9d, 0xaa, 0x56, 0x76, 0x02, 0x21, 0x59,
-	0x57, 0x04, 0xeb, 0x0f, 0xe0, 0x85, 0xfe, 0xac, 0x63, 0x85, 0x6a, 0x75, 0x3e, 0x60, 0x3f, 0x8c,
-	0xca, 0x4f, 0xfd, 0x1c, 0x92, 0x10, 0xde, 0xce, 0x9f, 0x74, 0x7e, 0xc1, 0xaa, 0x7e, 0xbc, 0xcb,
-	0xa8, 0xb2, 0x3a, 0x17, 0x45, 0x75, 0xde, 0x87, 0xf3, 0x03, 0xcf, 0x77, 0xd7, 0xa9, 0x7c, 0xf2,
-	0x6c, 0xb3, 0xa0, 0x3c, 0xdf, 0x2c, 0x28, 0x7f, 0x6c, 0x16, 0x94, 0x27, 0x5b, 0x85, 0x91, 0xe7,
-	0x5b, 0x85, 0x91, 0xdf, 0xb6, 0x0a, 0x23, 0x9f, 0x2e, 0x54, 0x5d, 0xbe, 0x51, 0x5f, 0xd7, 0x6d,
-	0x52, 0x33, 0x6c, 0xc2, 0x6a, 0x84, 0xb5, 0xe1, 0xbf, 0x97, 0xe0, 0x37, 0xe6, 0x8d, 0x07, 0x1d,
-	0xb7, 0xaf, 0x19, 0x60, 0xb6, 0xbe, 0x4f, 0x7c, 0x6a, 0xcd, 0xff, 0x1f, 0x00, 0x00, 0xff, 0xff,
-	0x6d, 0xa5, 0x22, 0x70, 0x1c, 0x14, 0x00, 0x00,
+	// 1655 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x58, 0xcf, 0x6f, 0xdb, 0x46,
+	0x16, 0x36, 0x65, 0xc7, 0xb1, 0xc7, 0xce, 0x8f, 0x9d, 0x78, 0xb3, 0x8a, 0xe2, 0x95, 0x13, 0x06,
+	0xbb, 0xeb, 0x24, 0x5b, 0xd1, 0x96, 0x11, 0x34, 0x3f, 0xea, 0x38, 0x96, 0xe5, 0x38, 0x82, 0x13,
+	0xc4, 0xa5, 0xd3, 0x04, 0x68, 0x8b, 0x30, 0x63, 0x72, 0x2a, 0x13, 0xa1, 0x48, 0x66, 0x66, 0x24,
+	0x47, 0x0d, 0x7a, 0x48, 0x0b, 0xb4, 0x39, 0x06, 0x68, 0x7b, 0xcf, 0xa5, 0xfd, 0x03, 0x7a, 0xef,
+	0x3d, 0xb7, 0x06, 0x0d, 0x0a, 0xe4, 0x94, 0x16, 0x4e, 0x0f, 0x45, 0x4f, 0x45, 0xef, 0x05, 0x0a,
+	0x0e, 0x87, 0x94, 0x28, 0xd1, 0x12, 0x25, 0xfb, 0x26, 0x0d, 0xe7, 0x7d, 0xef, 0xfb, 0x1e, 0xdf,
+	0xcc, 0x7b, 0x8f, 0x40, 0x31, 0x6d, 0x86, 0x89, 0xbe, 0x89, 0x4c, 0x5b, 0xa3, 0x58, 0xaf, 0x12,
+	0x93, 0xd5, 0x15, 0x5d, 0xaf, 0x29, 0x2e, 0x71, 0x6a, 0xa6, 0x81, 0x89, 0x52, 0x9b, 0x55, 0x1e,
+	0x54, 0x31, 0xa9, 0xe7, 0x5c, 0xe2, 0x30, 0x07, 0x9e, 0x8a, 0x31, 0xc8, 0xe9, 0x7a, 0x2d, 0x17,
+	0x18, 0xe4, 0x6a, 0xb3, 0x99, 0xc9, 0xb2, 0xe3, 0x94, 0x2d, 0xac, 0x20, 0xd7, 0x54, 0x90, 0x6d,
+	0x3b, 0x0c, 0x31, 0xd3, 0xb1, 0xa9, 0x0f, 0x91, 0x99, 0x28, 0x3b, 0x65, 0x87, 0xff, 0x54, 0xbc,
+	0x5f, 0x62, 0x75, 0x4a, 0xd8, 0xf0, 0x7f, 0x1b, 0xd5, 0x8f, 0x14, 0x66, 0x56, 0x30, 0x65, 0xa8,
+	0xe2, 0x8a, 0x0d, 0xf9, 0x24, 0x54, 0x43, 0x16, 0xbe, 0xcd, 0xcc, 0x4e, 0x36, 0xb5, 0x59, 0x85,
+	0x6e, 0x22, 0x82, 0x0d, 0x4d, 0x77, 0x6c, 0x5a, 0xad, 0x84, 0x16, 0xff, 0xe9, 0x60, 0xb1, 0x65,
+	0x12, 0x2c, 0xb6, 0x4d, 0x32, 0x6c, 0x1b, 0x98, 0x54, 0x4c, 0x9b, 0x29, 0x3a, 0xa9, 0xbb, 0xcc,
+	0x51, 0xee, 0xe3, 0xba, 0x50, 0x28, 0x9f, 0x07, 0xc7, 0xdf, 0xf5, 0x62, 0xb6, 0x24, 0xb0, 0x57,
+	0xb0, 0x8d, 0xa9, 0x49, 0x55, 0xfc, 0xa0, 0x8a, 0x29, 0x83, 0xc7, 0xc0, 0x88, 0xef, 0xc0, 0x34,
+	0xd2, 0xd2, 0x09, 0x69, 0x7a, 0x54, 0xdd, 0xcf, 0xff, 0x97, 0x0c, 0xf9, 0x11, 0x98, 0x8c, 0xb7,
+	0xa4, 0xae, 0x63, 0x53, 0x0c, 0x3f, 0x00, 0x07, 0xca, 0xfe, 0x92, 0x46, 0x19, 0x62, 0x98, 0xdb,
+	0x8f, 0xe5, 0x67, 0x72, 0x3b, 0xbd, 0x96, 0xda, 0x6c, 0xae, 0x05, 0x6b, 0xdd, 0xb3, 0x2b, 0x0c,
+	0x3d, 0x7f, 0x3d, 0x35, 0xa0, 0x8e, 0x97, 0x9b, 0xd6, 0xe4, 0x49, 0x90, 0x89, 0x38, 0x5f, 0xf2,
+	0xe0, 0x02, 0xd6, 0x32, 0x6a, 0x11, 0x15, 0x3c, 0x15, 0xcc, 0x0a, 0x60, 0x98, 0xbb, 0xa7, 0x69,
+	0xe9, 0xc4, 0xe0, 0xf4, 0x58, 0xfe, 0x4c, 0x2e, 0x41, 0xa6, 0xe4, 0x38, 0x88, 0x2a, 0x2c, 0xe5,
+	0xd3, 0xe0, 0x7f, 0xed, 0x2e, 0xd6, 0x19, 0x22, 0x6c, 0x8d, 0x38, 0xae, 0x43, 0x91, 0x15, 0xb2,
+	0x79, 0x22, 0x81, 0xe9, 0xee, 0x7b, 0x05, 0xb7, 0x0f, 0xc1, 0xa8, 0x1b, 0x2c, 0x8a, 0x88, 0x5d,
+	0x4e, 0x46, 0x4f, 0x80, 0x2f, 0x1a, 0x86, 0xe9, 0xa5, 0x70, 0x03, 0xba, 0x01, 0x28, 0x4f, 0x83,
+	0xff, 0xc6, 0x31, 0x71, 0xdc, 0x36, 0xd2, 0x9f, 0x4b, 0xf1, 0x02, 0x23, 0x5b, 0xc3, 0x37, 0xdd,
+	0xc6, 0x79, 0xbe, 0x27, 0xce, 0x2a, 0xae, 0x38, 0x35, 0x64, 0xc5, 0x52, 0x5e, 0x00, 0xfb, 0xb8,
+	0xeb, 0x0e, 0xa9, 0x08, 0x8f, 0x83, 0x51, 0xdd, 0x32, 0xb1, 0xcd, 0xbc, 0x67, 0x29, 0xfe, 0x6c,
+	0xc4, 0x5f, 0x28, 0x19, 0xf2, 0x17, 0x12, 0x38, 0xc9, 0x95, 0xdc, 0x46, 0x96, 0x69, 0x20, 0xe6,
+	0x90, 0xa6, 0x50, 0x91, 0xee, 0x89, 0x0e, 0xe7, 0xc1, 0xe1, 0x80, 0xb4, 0x86, 0x0c, 0x83, 0x60,
+	0x4a, 0x7d, 0x27, 0x05, 0xf8, 0xe7, 0xeb, 0xa9, 0x83, 0x75, 0x54, 0xb1, 0x2e, 0xca, 0xe2, 0x81,
+	0xac, 0x1e, 0x0a, 0xf6, 0x2e, 0xfa, 0x2b, 0x17, 0x47, 0x9e, 0x3c, 0x9b, 0x1a, 0xf8, 0xed, 0xd9,
+	0xd4, 0x80, 0x7c, 0x13, 0xc8, 0x9d, 0x88, 0x88, 0x68, 0x9e, 0x06, 0x87, 0x83, 0x83, 0x1e, 0xba,
+	0xf3, 0x19, 0x1d, 0xd2, 0x9b, 0xf6, 0x7b, 0xce, 0xda, 0xa5, 0xad, 0x35, 0x39, 0x4f, 0x26, 0xad,
+	0xcd, 0x57, 0x07, 0x69, 0x2d, 0xfe, 0x3b, 0x49, 0x8b, 0x12, 0x69, 0x48, 0x6b, 0x8b, 0xa4, 0x90,
+	0xd6, 0x12, 0x35, 0xf9, 0x38, 0x38, 0xc6, 0x01, 0x6f, 0x6d, 0x12, 0x87, 0x31, 0x0b, 0xf3, 0x63,
+	0x1f, 0x24, 0xe7, 0xb7, 0x29, 0x71, 0xfc, 0x5b, 0x9e, 0x0a, 0x37, 0x53, 0x60, 0x8c, 0x5a, 0x88,
+	0x6e, 0x6a, 0x15, 0xcc, 0x30, 0xe1, 0x1e, 0x06, 0x55, 0xc0, 0x97, 0x6e, 0x78, 0x2b, 0x30, 0x0f,
+	0xfe, 0xd9, 0xb4, 0x41, 0x43, 0x96, 0xe5, 0x6c, 0x21, 0x5b, 0xc7, 0x5c, 0xfb, 0xa0, 0x7a, 0xa4,
+	0xb1, 0x75, 0x31, 0x78, 0x04, 0xef, 0x82, 0xb4, 0x8d, 0x1f, 0x32, 0x8d, 0x60, 0xd7, 0xc2, 0xb6,
+	0x49, 0x37, 0x35, 0x1d, 0xd9, 0x86, 0x27, 0x16, 0xa7, 0x07, 0x79, 0xce, 0x67, 0x72, 0x7e, 0x5d,
+	0xc8, 0x05, 0x75, 0x21, 0x77, 0x2b, 0xa8, 0x0b, 0x85, 0x11, 0xef, 0x0e, 0x7b, 0xfa, 0xf3, 0x94,
+	0xa4, 0x1e, 0xf5, 0x50, 0xd4, 0x00, 0x64, 0x29, 0xc0, 0x80, 0xeb, 0x60, 0xbf, 0x8b, 0xf4, 0xfb,
+	0x98, 0xd1, 0xf4, 0x10, 0xbf, 0x95, 0x2e, 0x24, 0x3a, 0x42, 0x41, 0x04, 0x8c, 0x75, 0x8f, 0xf3,
+	0x1a, 0x47, 0x50, 0x03, 0x24, 0xb9, 0x28, 0x0e, 0x71, 0xb8, 0x2b, 0xc8, 0x38, 0x7f, 0x63, 0x11,
+	0x31, 0x94, 0xe0, 0xa6, 0xff, 0x31, 0xb8, 0xc0, 0x3a, 0xc2, 0x88, 0xe0, 0x77, 0xc8, 0x36, 0x08,
+	0x86, 0xa8, 0xf9, 0xb1, 0x1f, 0xe5, 0x21, 0x95, 0xff, 0x86, 0x5b, 0xe0, 0x88, 0x1b, 0x82, 0x94,
+	0x6c, 0xca, 0xbc, 0x60, 0xd3, 0xf4, 0x20, 0x0f, 0xc1, 0x42, 0x6f, 0x21, 0x68, 0xb0, 0xb9, 0x43,
+	0x90, 0xeb, 0x62, 0x22, 0x4a, 0x47, 0x9c, 0x07, 0xf9, 0x7b, 0x09, 0x4c, 0xc4, 0x05, 0x0f, 0xde,
+	0x05, 0xe3, 0x65, 0xcb, 0xd9, 0x40, 0x96, 0x86, 0x6d, 0x46, 0xea, 0xe2, 0x42, 0x3b, 0x97, 0x88,
+	0xca, 0x0a, 0x37, 0xe4, 0x68, 0xcb, 0x9e, 0xb1, 0x20, 0x30, 0xe6, 0x03, 0xf2, 0x25, 0xb8, 0x0c,
+	0x86, 0x0c, 0xc4, 0x10, 0x8f, 0xc2, 0x58, 0xfe, 0x6c, 0xa7, 0x72, 0xd8, 0x44, 0xcb, 0x23, 0x2f,
+	0xd0, 0xb8, 0xb9, 0xfc, 0x4a, 0x02, 0x99, 0x9d, 0x95, 0xc3, 0x35, 0x30, 0xee, 0xa7, 0xb8, 0xaf,
+	0x5d, 0xa8, 0xe8, 0xc5, 0xdb, 0xb5, 0x01, 0xd5, 0x3f, 0x46, 0x22, 0x2e, 0xf7, 0x00, 0xac, 0x51,
+	0x5d, 0xab, 0x20, 0x56, 0xf5, 0x9a, 0x11, 0x81, 0x9b, 0xea, 0x5e, 0xd4, 0x6f, 0xaf, 0x2f, 0xdd,
+	0xf0, 0x8d, 0x22, 0xe0, 0x87, 0x6b, 0x54, 0x8f, 0xac, 0x17, 0x86, 0xfd, 0xc8, 0xc8, 0xff, 0x07,
+	0x67, 0x78, 0xba, 0xa9, 0xb8, 0x6c, 0x52, 0x86, 0x49, 0x23, 0xdf, 0x54, 0xbc, 0x85, 0x88, 0x51,
+	0xc4, 0xb6, 0x53, 0x09, 0x2b, 0xd5, 0x32, 0x38, 0x9b, 0x68, 0xb7, 0xc8, 0xcf, 0xa3, 0x60, 0xd8,
+	0xe0, 0x2b, 0xbc, 0xf8, 0x8f, 0xaa, 0xe2, 0x9f, 0x9c, 0x15, 0xed, 0x8c, 0x5f, 0x84, 0xb0, 0xc1,
+	0x8b, 0x4e, 0xa9, 0x18, 0xba, 0x79, 0x2c, 0x81, 0x7f, 0xef, 0xb0, 0x41, 0x20, 0xdf, 0x03, 0x07,
+	0xdd, 0xe6, 0x67, 0x41, 0x7b, 0x91, 0x4f, 0x94, 0x3a, 0x11, 0x58, 0xf1, 0xa6, 0x5b, 0xf0, 0xe4,
+	0x12, 0x38, 0x10, 0xd9, 0x06, 0xd3, 0x40, 0x1c, 0xae, 0x62, 0xf4, 0xac, 0x15, 0x61, 0x16, 0x80,
+	0xa0, 0x86, 0x96, 0x8a, 0xe2, 0xc4, 0x35, 0xad, 0xc8, 0xd7, 0x81, 0xc2, 0xd5, 0x2c, 0x5a, 0xd6,
+	0x1a, 0x32, 0x09, 0xbd, 0x8d, 0xac, 0x25, 0xc7, 0xf6, 0x6e, 0xdf, 0x42, 0xb4, 0xe4, 0x97, 0x8a,
+	0x09, 0x6e, 0x88, 0x6f, 0x24, 0x30, 0x93, 0x1c, 0x4e, 0xc4, 0xeb, 0x01, 0xf8, 0x87, 0x8b, 0x4c,
+	0xa2, 0xd5, 0x90, 0xe5, 0xb5, 0xb6, 0xbc, 0x22, 0x88, 0x90, 0x5d, 0x4d, 0x16, 0x32, 0x64, 0x92,
+	0x86, 0xa3, 0xb0, 0xe2, 0xd8, 0x8d, 0x04, 0x38, 0xe8, 0x46, 0xb6, 0xc8, 0xdb, 0x12, 0x38, 0xd9,
+	0xd5, 0x2a, 0xb6, 0xe0, 0x4b, 0x89, 0x0b, 0xfe, 0x2e, 0x8b, 0x2a, 0x5c, 0x00, 0xe3, 0xa1, 0xf9,
+	0x7d, 0x5c, 0x17, 0xc5, 0x65, 0x32, 0xd7, 0x68, 0xe3, 0x73, 0x7e, 0x1b, 0x9f, 0x5b, 0xab, 0x6e,
+	0x58, 0xa6, 0xbe, 0x8a, 0xeb, 0xea, 0x58, 0x60, 0xb1, 0x8a, 0xeb, 0xf2, 0x04, 0x80, 0x7e, 0xa2,
+	0x22, 0x82, 0x1a, 0xc7, 0xe4, 0x1e, 0x38, 0x12, 0x59, 0x15, 0x2f, 0xa1, 0x04, 0x86, 0x5d, 0xbe,
+	0xd2, 0xf5, 0x86, 0x88, 0x46, 0xde, 0x33, 0x11, 0x59, 0x2a, 0x00, 0xf2, 0x3f, 0x1d, 0x05, 0xfb,
+	0xb8, 0x0b, 0xb8, 0x2d, 0x81, 0x89, 0xb8, 0xd9, 0x00, 0x5e, 0x49, 0x84, 0xde, 0x61, 0x20, 0xc9,
+	0x2c, 0xee, 0x02, 0xc1, 0x97, 0x2c, 0x2f, 0x7f, 0xfa, 0xf2, 0xd7, 0x2f, 0x53, 0x0b, 0x70, 0xbe,
+	0xfb, 0x44, 0x19, 0xbe, 0x08, 0x31, 0x7c, 0x28, 0x8f, 0x82, 0x13, 0xf0, 0x09, 0x7c, 0x29, 0x89,
+	0x88, 0x46, 0xa7, 0x0c, 0xb8, 0xd0, 0x3b, 0xc3, 0xc8, 0xf4, 0x92, 0xb9, 0xd2, 0x3f, 0x80, 0x50,
+	0x78, 0x81, 0x2b, 0x9c, 0x83, 0xb3, 0x3d, 0x28, 0xf4, 0xe7, 0x1a, 0xf8, 0x38, 0x05, 0xd2, 0x3b,
+	0x0c, 0x2b, 0x14, 0x5e, 0xef, 0x93, 0x59, 0xec, 0x5c, 0x94, 0xb9, 0xb1, 0x47, 0x68, 0x42, 0xf4,
+	0x35, 0x2e, 0xba, 0x00, 0xaf, 0xf4, 0x2a, 0xda, 0x1b, 0x4f, 0x09, 0xd3, 0xc2, 0x91, 0x03, 0xfe,
+	0x25, 0x81, 0x7f, 0xc5, 0xcf, 0x3e, 0x14, 0xae, 0xf6, 0x4d, 0xba, 0x7d, 0xc8, 0xca, 0x5c, 0xdf,
+	0x1b, 0x30, 0x11, 0x80, 0x15, 0x1e, 0x80, 0x45, 0xb8, 0xd0, 0x47, 0x00, 0x1c, 0xb7, 0x49, 0xff,
+	0x1f, 0x92, 0x68, 0xaf, 0x63, 0x07, 0x15, 0x78, 0x35, 0x39, 0xeb, 0x4e, 0x23, 0x57, 0x66, 0x65,
+	0xd7, 0x38, 0x42, 0xf8, 0x22, 0x17, 0x7e, 0x09, 0x5e, 0x48, 0xf0, 0x89, 0x28, 0x00, 0xd2, 0x22,
+	0x57, 0x74, 0x8c, 0xe4, 0xe6, 0x01, 0xa6, 0x2f, 0xc9, 0x31, 0xa3, 0x58, 0x5f, 0x92, 0xe3, 0x26,
+	0xa9, 0xfe, 0x24, 0x47, 0x8a, 0x1a, 0xfc, 0x41, 0x12, 0x75, 0x22, 0x32, 0x44, 0xc1, 0xcb, 0xc9,
+	0x29, 0xc6, 0xcd, 0x66, 0x99, 0x85, 0xbe, 0xed, 0x85, 0xb4, 0xf3, 0x5c, 0x5a, 0x1e, 0xce, 0x74,
+	0x97, 0xc6, 0x04, 0x80, 0xff, 0x81, 0x09, 0x7e, 0x96, 0x02, 0x27, 0xba, 0xcd, 0x29, 0xbd, 0xdc,
+	0x61, 0xdd, 0xa7, 0xa6, 0x5e, 0xee, 0xb0, 0x04, 0xc3, 0x93, 0x5c, 0xe0, 0xda, 0xdf, 0x81, 0x17,
+	0xbb, 0x6b, 0x77, 0xb1, 0x6d, 0x98, 0x76, 0xb9, 0x91, 0xc7, 0x62, 0xe6, 0x83, 0x5f, 0xa7, 0xc0,
+	0xa9, 0x04, 0x0d, 0x31, 0xbc, 0x99, 0x9c, 0x7a, 0xa2, 0x46, 0x3c, 0xb3, 0xb6, 0x77, 0x80, 0x22,
+	0x1c, 0xab, 0x3c, 0x1c, 0xcb, 0x70, 0xa9, 0x7b, 0x38, 0x48, 0x88, 0xd8, 0x88, 0x08, 0xe1, 0x98,
+	0x9a, 0xdf, 0xe0, 0xc3, 0xdf, 0xdb, 0x1a, 0xf8, 0x68, 0x5f, 0x4a, 0x61, 0x0f, 0xbd, 0xc5, 0x0e,
+	0x53, 0x42, 0xa6, 0xb0, 0x1b, 0x88, 0x3e, 0x92, 0x40, 0x60, 0x68, 0xad, 0x65, 0xfc, 0xab, 0x94,
+	0x18, 0xd9, 0x13, 0x34, 0xe4, 0xf0, 0x56, 0x72, 0xd2, 0xc9, 0xc7, 0x85, 0xcc, 0x7b, 0x7b, 0x8c,
+	0x2a, 0xa2, 0x73, 0x89, 0x47, 0xe7, 0x1c, 0x9c, 0xeb, 0xb9, 0xca, 0x99, 0x06, 0xfc, 0x4e, 0x02,
+	0x63, 0x4d, 0x5d, 0x30, 0x7c, 0xbb, 0x87, 0xd7, 0xd5, 0xdc, 0x4d, 0x67, 0xce, 0xf7, 0x6e, 0x28,
+	0xf8, 0xcf, 0x70, 0xfe, 0x67, 0xe0, 0x74, 0x82, 0xb7, 0xeb, 0x77, 0xd9, 0x77, 0x9e, 0x6f, 0x67,
+	0xa5, 0x17, 0xdb, 0x59, 0xe9, 0x97, 0xed, 0xac, 0xf4, 0xf4, 0x4d, 0x76, 0xe0, 0xc5, 0x9b, 0xec,
+	0xc0, 0xab, 0x37, 0xd9, 0x81, 0xf7, 0xe7, 0xcb, 0x26, 0xdb, 0xac, 0x6e, 0xe4, 0x74, 0xa7, 0xa2,
+	0xe8, 0x0e, 0xad, 0x38, 0xb4, 0x09, 0xf4, 0xad, 0x10, 0xb4, 0x36, 0xa7, 0x3c, 0x6c, 0xb9, 0x38,
+	0xeb, 0x2e, 0xa6, 0x1b, 0xc3, 0xfc, 0x43, 0xd5, 0xdc, 0xdf, 0x01, 0x00, 0x00, 0xff, 0xff, 0xc8,
+	0x5d, 0x14, 0x6e, 0x5a, 0x19, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -1496,6 +1598,8 @@ type QueryClient interface {
 	// QueryAllPairsValConAddrByConsumerChainID returns a list of pair valconsensus address
 	// between provider and consumer chain
 	QueryAllPairsValConAddrByConsumerChainID(ctx context.Context, in *QueryAllPairsValConAddrByConsumerChainIDRequest, opts ...grpc.CallOption) (*QueryAllPairsValConAddrByConsumerChainIDResponse, error)
+	// QueryParams returns all current values of provider parameters
+	QueryParams(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error)
 }
 
 type queryClient struct {
@@ -1605,6 +1709,15 @@ func (c *queryClient) QueryAllPairsValConAddrByConsumerChainID(ctx context.Conte
 	return out, nil
 }
 
+func (c *queryClient) QueryParams(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error) {
+	out := new(QueryParamsResponse)
+	err := c.cc.Invoke(ctx, "/interchain_security.ccv.provider.v1.Query/QueryParams", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // QueryServer is the server API for Query service.
 type QueryServer interface {
 	// ConsumerGenesis queries the genesis state needed to start a consumer chain
@@ -1638,6 +1751,8 @@ type QueryServer interface {
 	// QueryAllPairsValConAddrByConsumerChainID returns a list of pair valconsensus address
 	// between provider and consumer chain
 	QueryAllPairsValConAddrByConsumerChainID(context.Context, *QueryAllPairsValConAddrByConsumerChainIDRequest) (*QueryAllPairsValConAddrByConsumerChainIDResponse, error)
+	// QueryParams returns all current values of provider parameters
+	QueryParams(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error)
 }
 
 // UnimplementedQueryServer can be embedded to have forward compatible implementations.
@@ -1677,6 +1792,9 @@ func (*UnimplementedQueryServer) QueryProposedConsumerChainIDs(ctx context.Conte
 func (*UnimplementedQueryServer) QueryAllPairsValConAddrByConsumerChainID(ctx context.Context, req *QueryAllPairsValConAddrByConsumerChainIDRequest) (*QueryAllPairsValConAddrByConsumerChainIDResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method QueryAllPairsValConAddrByConsumerChainID not implemented")
 }
+func (*UnimplementedQueryServer) QueryParams(ctx context.Context, req *QueryParamsRequest) (*QueryParamsResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method QueryParams not implemented")
+}
 
 func RegisterQueryServer(s grpc1.Server, srv QueryServer) {
 	s.RegisterService(&_Query_serviceDesc, srv)
@@ -1880,6 +1998,24 @@ func _Query_QueryAllPairsValConAddrByConsumerChainID_Handler(srv interface{}, ct
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Query_QueryParams_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).QueryParams(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/interchain_security.ccv.provider.v1.Query/QueryParams",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).QueryParams(ctx, req.(*QueryParamsRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 var _Query_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "interchain_security.ccv.provider.v1.Query",
 	HandlerType: (*QueryServer)(nil),
@@ -1928,6 +2064,10 @@ var _Query_serviceDesc = grpc.ServiceDesc{
 			MethodName: "QueryAllPairsValConAddrByConsumerChainID",
 			Handler:    _Query_QueryAllPairsValConAddrByConsumerChainID_Handler,
 		},
+		{
+			MethodName: "QueryParams",
+			Handler:    _Query_QueryParams_Handler,
+		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "interchain_security/ccv/provider/v1/query.proto",
@@ -2883,6 +3023,62 @@ func (m *PairValConAddrProviderAndConsumer) MarshalToSizedBuffer(dAtA []byte) (i
 	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 encodeVarintQuery(dAtA []byte, offset int, v uint64) int {
 	offset -= sovQuery(v)
 	base := offset
@@ -3292,6 +3488,26 @@ func (m *PairValConAddrProviderAndConsumer) Size() (n int) {
 	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 sovQuery(x uint64) (n int) {
 	return (math_bits.Len64(x|1) + 6) / 7
 }
@@ -5716,6 +5932,139 @@ func (m *PairValConAddrProviderAndConsumer) Unmarshal(dAtA []byte) error {
 	}
 	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 skipQuery(dAtA []byte) (n int, err error) {
 	l := len(dAtA)
 	iNdEx := 0
diff --git a/x/ccv/provider/types/query.pb.gw.go b/x/ccv/provider/types/query.pb.gw.go
index e3663ede15..5e8b514a9e 100644
--- a/x/ccv/provider/types/query.pb.gw.go
+++ b/x/ccv/provider/types/query.pb.gw.go
@@ -339,6 +339,24 @@ func local_request_Query_QueryAllPairsValConAddrByConsumerChainID_0(ctx context.
 
 }
 
+func request_Query_QueryParams_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.QueryParams(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func local_request_Query_QueryParams_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.QueryParams(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.
@@ -598,6 +616,29 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 
 	})
 
+	mux.Handle("GET", pattern_Query_QueryParams_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_QueryParams_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_QueryParams_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
 	return nil
 }
 
@@ -859,6 +900,26 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie
 
 	})
 
+	mux.Handle("GET", pattern_Query_QueryParams_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_QueryParams_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_QueryParams_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
 	return nil
 }
 
@@ -884,6 +945,8 @@ var (
 	pattern_Query_QueryProposedConsumerChainIDs_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"interchain_security", "ccv", "provider", "proposed_consumer_chains"}, "", runtime.AssumeColonVerbOpt(false)))
 
 	pattern_Query_QueryAllPairsValConAddrByConsumerChainID_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"interchain_security", "ccv", "provider", "consumer_chain_id"}, "", runtime.AssumeColonVerbOpt(false)))
+
+	pattern_Query_QueryParams_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"interchain_security", "ccv", "provider", "params"}, "", runtime.AssumeColonVerbOpt(false)))
 )
 
 var (
@@ -908,4 +971,6 @@ var (
 	forward_Query_QueryProposedConsumerChainIDs_0 = runtime.ForwardResponseMessage
 
 	forward_Query_QueryAllPairsValConAddrByConsumerChainID_0 = runtime.ForwardResponseMessage
+
+	forward_Query_QueryParams_0 = runtime.ForwardResponseMessage
 )
diff --git a/x/ccv/types/shared_consumer.pb.go b/x/ccv/types/shared_consumer.pb.go
index 00a07223ab..da1408373c 100644
--- a/x/ccv/types/shared_consumer.pb.go
+++ b/x/ccv/types/shared_consumer.pb.go
@@ -195,10 +195,8 @@ func (m *ConsumerParams) GetProviderRewardDenoms() []string {
 	return nil
 }
 
-// ConsumerGenesisState defines the CCV consumer chain genesis state.
-//
-// Note this type is referenced in both the consumer and provider CCV modules,
-// and persisted on the provider, see MakeConsumerGenesis and SetConsumerGenesis.
+// ConsumerGenesisState defines shared genesis information between provider and
+// consumer
 type ConsumerGenesisState struct {
 	Params   ConsumerParams `protobuf:"bytes,1,opt,name=params,proto3" json:"params"`
 	Provider ProviderInfo   `protobuf:"bytes,2,opt,name=provider,proto3" json:"provider"`
@@ -336,81 +334,57 @@ func init() {
 }
 
 var fileDescriptor_d0a8be0efc64dfbc = []byte{
-	// 1182 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x56, 0x4f, 0x53, 0x1b, 0x37,
-	0x14, 0xc7, 0x81, 0x10, 0x5b, 0x40, 0x42, 0x04, 0x71, 0x37, 0x30, 0x35, 0x8e, 0xdb, 0xce, 0x78,
-	0xda, 0x66, 0xb7, 0x21, 0xe9, 0x74, 0xa6, 0x87, 0xce, 0x04, 0xd3, 0x14, 0x3a, 0x69, 0xa0, 0x0b,
-	0xe1, 0x90, 0xce, 0x54, 0x23, 0x4b, 0xc2, 0xd6, 0x64, 0x2d, 0x79, 0x24, 0xed, 0x52, 0xae, 0x3d,
-	0xf7, 0x90, 0x63, 0x3f, 0x52, 0x8e, 0x39, 0xe6, 0xd4, 0x76, 0x92, 0x2f, 0xd2, 0xd1, 0x9f, 0x35,
-	0x76, 0x00, 0x97, 0xde, 0x56, 0x7a, 0xbf, 0xdf, 0xfb, 0xff, 0xf4, 0x16, 0x7c, 0xc5, 0x85, 0x61,
-	0x8a, 0xf4, 0x31, 0x17, 0x48, 0x33, 0x92, 0x2b, 0x6e, 0x4e, 0x13, 0x42, 0x8a, 0xa4, 0x78, 0x90,
-	0xe8, 0x3e, 0x56, 0x8c, 0x22, 0x22, 0x85, 0xce, 0x07, 0x4c, 0xc5, 0x43, 0x25, 0x8d, 0x84, 0x6b,
-	0x17, 0x30, 0x62, 0x42, 0x8a, 0xb8, 0x78, 0xb0, 0xb6, 0x6e, 0x98, 0xa0, 0x4c, 0x0d, 0xb8, 0x30,
-	0x09, 0xee, 0x12, 0x9e, 0x98, 0xd3, 0x21, 0xd3, 0x9e, 0xb8, 0x96, 0xf0, 0x2e, 0x49, 0x32, 0xde,
-	0xeb, 0x1b, 0x92, 0x71, 0x26, 0x8c, 0x4e, 0xc6, 0xd0, 0xc5, 0x83, 0xb1, 0x53, 0x20, 0xdc, 0xb3,
-	0x04, 0x22, 0x15, 0x4b, 0x48, 0x1f, 0x0b, 0xc1, 0x32, 0x8b, 0x0a, 0x9f, 0x01, 0xd2, 0xe8, 0x49,
-	0xd9, 0xcb, 0x58, 0xe2, 0x4e, 0xdd, 0xfc, 0x38, 0xa1, 0xb9, 0xc2, 0x86, 0x4b, 0x11, 0xe4, 0xab,
-	0x3d, 0xd9, 0x93, 0xee, 0x33, 0xb1, 0x5f, 0xe1, 0xf6, 0xb3, 0x29, 0x41, 0x9f, 0x70, 0xc5, 0x02,
-	0x6c, 0xe3, 0x43, 0xe5, 0x86, 0x0f, 0x98, 0x36, 0x78, 0x30, 0xf4, 0x80, 0xd6, 0x1f, 0xf3, 0xe0,
-	0x66, 0x27, 0x64, 0x67, 0x1f, 0x2b, 0x3c, 0xd0, 0x30, 0x02, 0x37, 0x98, 0xc0, 0xdd, 0x8c, 0xd1,
-	0xa8, 0xd2, 0xac, 0xb4, 0xab, 0x69, 0x79, 0x84, 0x7b, 0xe0, 0xd3, 0x6e, 0x26, 0xc9, 0x4b, 0x8d,
-	0x86, 0x4c, 0x21, 0xca, 0xb5, 0x51, 0xbc, 0x9b, 0x5b, 0x5f, 0x91, 0x51, 0x58, 0xe8, 0x01, 0xd7,
-	0x9a, 0x4b, 0x11, 0x5d, 0x6b, 0x56, 0xda, 0xb3, 0xe9, 0x3d, 0x8f, 0xdd, 0x67, 0x6a, 0x7b, 0x0c,
-	0x79, 0x38, 0x06, 0x84, 0x3f, 0x82, 0x7b, 0x97, 0x6a, 0x41, 0x21, 0x4d, 0xd1, 0x6c, 0xb3, 0xd2,
-	0xae, 0xa5, 0x1b, 0xf4, 0x12, 0x25, 0x1d, 0x0f, 0x83, 0xdf, 0x82, 0xb5, 0xa1, 0x92, 0x05, 0xa7,
-	0x4c, 0xa1, 0x63, 0xc6, 0xd0, 0x50, 0xca, 0x0c, 0x61, 0x4a, 0x15, 0xd2, 0x46, 0x45, 0x73, 0x4e,
-	0x49, 0xbd, 0x44, 0x3c, 0x61, 0x6c, 0x5f, 0xca, 0xec, 0x31, 0xa5, 0xea, 0xc0, 0x28, 0xf8, 0x33,
-	0x80, 0x84, 0x14, 0xc8, 0x26, 0x47, 0xe6, 0xc6, 0x46, 0xc7, 0x25, 0x8d, 0xae, 0x37, 0x2b, 0xed,
-	0x85, 0xcd, 0xbb, 0xb1, 0xcf, 0x61, 0x5c, 0xe6, 0x30, 0xde, 0x0e, 0x05, 0xda, 0xaa, 0xbe, 0xfe,
-	0x6b, 0x63, 0xe6, 0xcf, 0xbf, 0x37, 0x2a, 0xe9, 0x32, 0x21, 0xc5, 0xa1, 0x67, 0xef, 0x3b, 0x32,
-	0xfc, 0x05, 0x7c, 0xe4, 0xa2, 0x39, 0x66, 0xea, 0x43, 0xbd, 0xf3, 0x57, 0xd7, 0x7b, 0xa7, 0xd4,
-	0x31, 0xa9, 0x7c, 0x07, 0x34, 0xcb, 0x96, 0x46, 0x8a, 0x4d, 0xa4, 0xf0, 0x58, 0x61, 0x62, 0x3f,
-	0xa2, 0x1b, 0x2e, 0xe2, 0x46, 0x89, 0x4b, 0x27, 0x60, 0x4f, 0x02, 0x0a, 0xde, 0x07, 0xb0, 0xcf,
-	0xb5, 0x91, 0x8a, 0x13, 0x9c, 0x21, 0x26, 0x8c, 0xe2, 0x4c, 0x47, 0x55, 0x57, 0xc0, 0xdb, 0x67,
-	0x92, 0xef, 0xbd, 0x00, 0x3e, 0x03, 0xcb, 0xb9, 0xe8, 0x4a, 0x41, 0xb9, 0xe8, 0x95, 0xe1, 0xd4,
-	0xae, 0x1e, 0xce, 0xad, 0x11, 0x39, 0x04, 0xf2, 0x10, 0xd4, 0xb5, 0x3c, 0x36, 0x48, 0x0e, 0x0d,
-	0xb2, 0x19, 0x32, 0x7d, 0xc5, 0x74, 0x5f, 0x66, 0x34, 0x02, 0xce, 0xfd, 0x15, 0x2b, 0xdd, 0x1b,
-	0x9a, 0xbd, 0xdc, 0x1c, 0x96, 0x22, 0xf8, 0x09, 0x58, 0x52, 0xec, 0x04, 0x2b, 0x8a, 0x28, 0x13,
-	0x72, 0xa0, 0xa3, 0x85, 0xe6, 0x6c, 0xbb, 0x96, 0x2e, 0xfa, 0xcb, 0x6d, 0x77, 0x07, 0x1f, 0x81,
-	0x51, 0xb1, 0xd1, 0x24, 0x7a, 0xd1, 0xa1, 0x57, 0x4b, 0x69, 0x3a, 0xc6, 0x6a, 0xbd, 0xad, 0x82,
-	0xd5, 0x72, 0x1c, 0x7e, 0x60, 0x82, 0x69, 0xae, 0x0f, 0x0c, 0x36, 0x0c, 0xee, 0x80, 0xf9, 0xa1,
-	0x1b, 0x0f, 0x37, 0x13, 0x0b, 0x9b, 0x9f, 0xc7, 0x97, 0xbf, 0x21, 0xf1, 0xe4, 0x40, 0x6d, 0xcd,
-	0xd9, 0xf8, 0xd3, 0xc0, 0x87, 0x5f, 0x02, 0x38, 0x72, 0xcc, 0xbf, 0x22, 0x88, 0x53, 0x37, 0x32,
-	0xb5, 0x74, 0xb9, 0x94, 0x74, 0x9c, 0x60, 0x97, 0xc2, 0x18, 0xac, 0x9c, 0xa1, 0x7d, 0xa7, 0x5b,
-	0xb8, 0x9f, 0x89, 0xdb, 0x23, 0xb8, 0x97, 0xec, 0x52, 0xb8, 0x0e, 0x6a, 0x82, 0x9d, 0x20, 0xe7,
-	0x97, 0x6b, 0xfa, 0x6a, 0x5a, 0x15, 0xec, 0xa4, 0x63, 0xcf, 0x10, 0x81, 0x3b, 0x1f, 0x9a, 0xd6,
-	0x36, 0xba, 0xd0, 0xe9, 0x5f, 0xc4, 0xbc, 0x4b, 0xe2, 0xf1, 0xe7, 0x2d, 0x1e, 0x7b, 0xd0, 0x6c,
-	0x5c, 0xee, 0xd6, 0x25, 0x24, 0x5d, 0x99, 0x74, 0xd5, 0x67, 0xa9, 0x0f, 0xa2, 0x33, 0x03, 0x52,
-	0x68, 0x26, 0x74, 0xae, 0x83, 0x0d, 0xdf, 0xf5, 0xf1, 0x7f, 0xda, 0x28, 0x69, 0xde, 0xcc, 0xa8,
-	0x88, 0x93, 0xf7, 0xf0, 0x57, 0xb0, 0x3c, 0xc0, 0x26, 0x57, 0xae, 0x0f, 0x31, 0x79, 0xc9, 0x8c,
-	0x8e, 0x6e, 0x34, 0x67, 0xdb, 0x0b, 0x9b, 0xf7, 0xa7, 0x55, 0xe6, 0xa7, 0xc0, 0x39, 0x3a, 0xe8,
-	0xec, 0x3b, 0x56, 0x28, 0xce, 0xad, 0x52, 0x99, 0xbf, 0xb5, 0x8d, 0x7e, 0x8b, 0x0b, 0x6e, 0x38,
-	0xce, 0x50, 0x81, 0x33, 0xa4, 0x99, 0x89, 0xaa, 0x4e, 0x7d, 0x73, 0xdc, 0x5f, 0xbb, 0x20, 0xe2,
-	0x23, 0x9c, 0x71, 0x8a, 0x8d, 0x54, 0xcf, 0x87, 0x14, 0x1b, 0x16, 0x34, 0x2e, 0x05, 0xfa, 0x11,
-	0xce, 0x0e, 0x98, 0x81, 0x06, 0xac, 0xf5, 0x99, 0x8d, 0x1a, 0x19, 0x69, 0x35, 0x6a, 0x66, 0x50,
-	0xee, 0xf0, 0xb6, 0x9c, 0x35, 0xa7, 0x7a, 0x73, 0x9a, 0xe7, 0x3b, 0x8e, 0x7d, 0x28, 0x8f, 0x1c,
-	0xd7, 0x9b, 0xda, 0xdd, 0x0e, 0xc6, 0xea, 0xfd, 0x8b, 0xa4, 0x14, 0x9e, 0x82, 0x8f, 0x65, 0x6e,
-	0xb4, 0xc1, 0x7e, 0x60, 0xa9, 0x3c, 0x11, 0xf6, 0x2d, 0x42, 0x3a, 0xc3, 0xba, 0xcf, 0x45, 0x2f,
-	0x02, 0xce, 0x70, 0x32, 0xcd, 0xf0, 0xde, 0x99, 0x82, 0xed, 0xc0, 0x0f, 0x56, 0xd7, 0xe5, 0x79,
-	0xd1, 0x41, 0xd0, 0x0c, 0x15, 0x88, 0x86, 0xcc, 0x9b, 0x1d, 0x3d, 0x55, 0x65, 0xa1, 0x16, 0x5c,
-	0x2b, 0x6c, 0x5e, 0x6d, 0x84, 0x2c, 0x65, 0x1b, 0x1b, 0xfc, 0x94, 0xeb, 0xb2, 0x5a, 0xf5, 0xa0,
-	0x79, 0x12, 0xa4, 0xe1, 0xef, 0x15, 0xd0, 0xc8, 0xb0, 0x36, 0x93, 0x7b, 0xc4, 0xad, 0x21, 0xe4,
-	0x33, 0x14, 0x2d, 0x3a, 0xd3, 0xdf, 0x4c, 0x33, 0xfd, 0x14, 0x6b, 0x33, 0xbe, 0x60, 0xb6, 0x2c,
-	0xdf, 0xa7, 0xbf, 0x0c, 0x3c, 0xbb, 0x1c, 0x02, 0xeb, 0x60, 0x7e, 0xa8, 0x58, 0xa7, 0x73, 0x14,
-	0x2d, 0xb9, 0xf1, 0x0b, 0xa7, 0xd6, 0x0b, 0x50, 0xbf, 0xb8, 0x86, 0x96, 0x11, 0xbc, 0xb3, 0x6f,
-	0xcb, 0x5c, 0x1a, 0x4e, 0xb0, 0x0d, 0x96, 0xcf, 0x75, 0xca, 0x35, 0x87, 0xb8, 0x59, 0x4c, 0xd4,
-	0xb9, 0xf5, 0x1c, 0xac, 0x5c, 0x50, 0x26, 0xf8, 0x1d, 0x58, 0x2f, 0xca, 0xe6, 0x1c, 0x9b, 0x47,
-	0xbb, 0x14, 0x99, 0xf6, 0x2f, 0x59, 0x2d, 0xbd, 0x3b, 0x82, 0x8c, 0x46, 0xec, 0xb1, 0x07, 0xb4,
-	0xbe, 0x06, 0xeb, 0x4f, 0xa7, 0x47, 0x3a, 0xe6, 0xf7, 0x6c, 0xe9, 0x77, 0xcb, 0x80, 0xdb, 0xe7,
-	0xe6, 0x0c, 0xae, 0x82, 0xeb, 0x85, 0x26, 0xbb, 0x34, 0xc4, 0xe8, 0x0f, 0x70, 0x17, 0x2c, 0xf9,
-	0xc9, 0x33, 0xa7, 0x6e, 0x4b, 0xba, 0xf8, 0x16, 0x36, 0xd7, 0xce, 0x2d, 0x93, 0xc3, 0xf2, 0xbf,
-	0xc5, 0x6f, 0x93, 0x57, 0x76, 0x9b, 0x2c, 0x96, 0x54, 0x2b, 0x6c, 0x75, 0x41, 0xfd, 0xe2, 0xa6,
-	0x81, 0x3b, 0x60, 0x2e, 0xe3, 0xda, 0x7a, 0x39, 0xeb, 0x5f, 0xa0, 0xff, 0xd3, 0x76, 0xa1, 0xe4,
-	0x4e, 0xc3, 0xd6, 0xb3, 0xd7, 0xef, 0x1a, 0x95, 0x37, 0xef, 0x1a, 0x95, 0x7f, 0xde, 0x35, 0x2a,
-	0xaf, 0xde, 0x37, 0x66, 0xde, 0xbc, 0x6f, 0xcc, 0xbc, 0x7d, 0xdf, 0x98, 0x79, 0xf1, 0xa8, 0xc7,
-	0x4d, 0x3f, 0xef, 0xc6, 0x44, 0x0e, 0x12, 0x22, 0xf5, 0x40, 0xea, 0xe4, 0xcc, 0xcc, 0xfd, 0xd1,
-	0x1f, 0x5a, 0xf1, 0x30, 0xf9, 0xcd, 0xfd, 0xa6, 0xb9, 0xbf, 0xca, 0xee, 0xbc, 0x8b, 0xef, 0xe1,
-	0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0xe0, 0xb5, 0xe5, 0x15, 0xc3, 0x0a, 0x00, 0x00,
+	// 789 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x54, 0x41, 0x73, 0xdc, 0x34,
+	0x14, 0x8e, 0xbb, 0x25, 0xdd, 0x68, 0xd3, 0xa6, 0x88, 0x50, 0x4c, 0x3a, 0xe3, 0xb8, 0x81, 0xc3,
+	0x0e, 0x4c, 0x6d, 0x92, 0xf4, 0xc4, 0x8d, 0x24, 0x94, 0xd2, 0x43, 0xb2, 0x38, 0xa1, 0xcc, 0xc0,
+	0x41, 0x23, 0x4b, 0x6f, 0xd7, 0x1a, 0x6c, 0xc9, 0x23, 0xc9, 0x0e, 0xfd, 0x05, 0x5c, 0x38, 0x70,
+	0xe4, 0x27, 0x95, 0x5b, 0x8f, 0x9c, 0x80, 0x49, 0xfe, 0x08, 0x63, 0xd9, 0x4e, 0xbc, 0x0c, 0xa1,
+	0xbd, 0xe9, 0xbd, 0xf7, 0x7d, 0x9f, 0xfd, 0x3d, 0xe9, 0x3d, 0xf4, 0x99, 0x90, 0x16, 0x34, 0xcb,
+	0xa8, 0x90, 0xc4, 0x00, 0xab, 0xb4, 0xb0, 0x2f, 0x63, 0xc6, 0xea, 0xb8, 0xde, 0x8d, 0x4d, 0x46,
+	0x35, 0x70, 0xc2, 0x94, 0x34, 0x55, 0x01, 0x3a, 0x2a, 0xb5, 0xb2, 0x0a, 0x6f, 0xfd, 0x07, 0x23,
+	0x62, 0xac, 0x8e, 0xea, 0xdd, 0xad, 0x87, 0x16, 0x24, 0x07, 0x5d, 0x08, 0x69, 0x63, 0x9a, 0x32,
+	0x11, 0xdb, 0x97, 0x25, 0x98, 0x96, 0xb8, 0x15, 0x8b, 0x94, 0xc5, 0xb9, 0x58, 0x64, 0x96, 0xe5,
+	0x02, 0xa4, 0x35, 0xf1, 0x00, 0x5d, 0xef, 0x0e, 0xa2, 0x8e, 0x10, 0x2c, 0x94, 0x5a, 0xe4, 0x10,
+	0xbb, 0x28, 0xad, 0xe6, 0x31, 0xaf, 0x34, 0xb5, 0x42, 0xc9, 0xae, 0xbe, 0xb9, 0x50, 0x0b, 0xe5,
+	0x8e, 0x71, 0x73, 0x6a, 0xb3, 0x3b, 0xbf, 0xac, 0xa2, 0x7b, 0x87, 0xdd, 0x2f, 0xcf, 0xa8, 0xa6,
+	0x85, 0xc1, 0x3e, 0xba, 0x03, 0x92, 0xa6, 0x39, 0x70, 0xdf, 0x0b, 0xbd, 0xe9, 0x38, 0xe9, 0x43,
+	0x7c, 0x82, 0x3e, 0x4e, 0x73, 0xc5, 0x7e, 0x34, 0xa4, 0x04, 0x4d, 0xb8, 0x30, 0x56, 0x8b, 0xb4,
+	0x6a, 0xbe, 0x41, 0xac, 0xa6, 0xd2, 0x14, 0xc2, 0x18, 0xa1, 0xa4, 0x7f, 0x2b, 0xf4, 0xa6, 0xa3,
+	0xe4, 0x51, 0x8b, 0x9d, 0x81, 0x3e, 0x1a, 0x20, 0xcf, 0x06, 0x40, 0xfc, 0x1c, 0x3d, 0xba, 0x51,
+	0x85, 0xb0, 0x8c, 0x4a, 0x09, 0xb9, 0x3f, 0x0a, 0xbd, 0xe9, 0x5a, 0xb2, 0xcd, 0x6f, 0x10, 0x39,
+	0x6c, 0x61, 0xf8, 0x73, 0xb4, 0x55, 0x6a, 0x55, 0x0b, 0x0e, 0x9a, 0xcc, 0x01, 0x48, 0xa9, 0x54,
+	0x4e, 0x28, 0xe7, 0x9a, 0x18, 0xab, 0xfd, 0xdb, 0x4e, 0xe4, 0x41, 0x8f, 0x78, 0x0a, 0x30, 0x53,
+	0x2a, 0xff, 0x82, 0x73, 0x7d, 0x6a, 0x35, 0xfe, 0x06, 0x61, 0xc6, 0x6a, 0x62, 0x45, 0x01, 0xaa,
+	0xb2, 0x8d, 0x3b, 0xa1, 0xb8, 0xff, 0x4e, 0xe8, 0x4d, 0x27, 0x7b, 0x1f, 0x46, 0x6d, 0x63, 0xa3,
+	0xbe, 0xb1, 0xd1, 0x51, 0xd7, 0xd8, 0x83, 0xf1, 0xab, 0x3f, 0xb7, 0x57, 0x7e, 0xfb, 0x6b, 0xdb,
+	0x4b, 0xee, 0x33, 0x56, 0x9f, 0xb5, 0xec, 0x99, 0x23, 0xe3, 0x1f, 0xd0, 0x07, 0xce, 0xcd, 0x1c,
+	0xf4, 0xbf, 0x75, 0x57, 0xdf, 0x5e, 0xf7, 0xfd, 0x5e, 0x63, 0x59, 0xfc, 0x19, 0x0a, 0xfb, 0x77,
+	0x46, 0x34, 0x2c, 0xb5, 0x70, 0xae, 0x29, 0x6b, 0x0e, 0xfe, 0x1d, 0xe7, 0x38, 0xe8, 0x71, 0xc9,
+	0x12, 0xec, 0x69, 0x87, 0xc2, 0x8f, 0x11, 0xce, 0x84, 0xb1, 0x4a, 0x0b, 0x46, 0x73, 0x02, 0xd2,
+	0x6a, 0x01, 0xc6, 0x1f, 0xbb, 0x0b, 0x7c, 0xf7, 0xba, 0xf2, 0x65, 0x5b, 0xc0, 0xc7, 0xe8, 0x7e,
+	0x25, 0x53, 0x25, 0xb9, 0x90, 0x8b, 0xde, 0xce, 0xda, 0xdb, 0xdb, 0xd9, 0xb8, 0x22, 0x77, 0x46,
+	0xf6, 0xd1, 0x03, 0xa3, 0xe6, 0x96, 0xa8, 0xd2, 0x92, 0xa6, 0x43, 0x36, 0xd3, 0x60, 0x32, 0x95,
+	0x73, 0x1f, 0xb9, 0xdf, 0x7f, 0xaf, 0xa9, 0x9e, 0x94, 0xf6, 0xa4, 0xb2, 0x67, 0x7d, 0x09, 0x7f,
+	0x84, 0xee, 0x6a, 0x38, 0xa7, 0x9a, 0x13, 0x0e, 0x52, 0x15, 0xc6, 0x9f, 0x84, 0xa3, 0xe9, 0x5a,
+	0xb2, 0xde, 0x26, 0x8f, 0x5c, 0x0e, 0x3f, 0x41, 0x57, 0x97, 0x4d, 0x96, 0xd1, 0xeb, 0x0e, 0xbd,
+	0xd9, 0x57, 0x93, 0x01, 0x6b, 0xe7, 0x77, 0x0f, 0x6d, 0xf6, 0xe3, 0xf0, 0x15, 0x48, 0x30, 0xc2,
+	0x9c, 0x5a, 0x6a, 0x01, 0x3f, 0x43, 0xab, 0xa5, 0x1b, 0x0f, 0x37, 0x13, 0x93, 0xbd, 0x4f, 0xa2,
+	0x9b, 0x07, 0x3b, 0x5a, 0x1e, 0xa8, 0x83, 0xdb, 0x8d, 0xff, 0xa4, 0xe3, 0xe3, 0xe7, 0x68, 0xdc,
+	0x7f, 0xda, 0x0d, 0xca, 0x64, 0x6f, 0xfa, 0x7f, 0x5a, 0xb3, 0x0e, 0xfb, 0xb5, 0x9c, 0xab, 0x4e,
+	0xe9, 0x8a, 0x8f, 0x1f, 0xa2, 0x35, 0x09, 0xe7, 0xc4, 0x31, 0xdd, 0x9c, 0x8c, 0x93, 0xb1, 0x84,
+	0xf3, 0xc3, 0x26, 0xde, 0xf9, 0xf9, 0x16, 0x5a, 0x1f, 0xb2, 0xf1, 0x31, 0x5a, 0x6f, 0x77, 0x09,
+	0x31, 0x8d, 0xa7, 0xce, 0xc9, 0xa7, 0x91, 0x48, 0x59, 0x34, 0xdc, 0x34, 0xd1, 0x60, 0xb7, 0x34,
+	0x6e, 0x5c, 0xd6, 0xb5, 0x21, 0x99, 0xb0, 0xeb, 0x00, 0x7f, 0x87, 0x36, 0x9a, 0xd7, 0x05, 0xd2,
+	0x54, 0xa6, 0x93, 0x6c, 0x0d, 0x45, 0x6f, 0x94, 0xec, 0x69, 0xad, 0xea, 0x3d, 0xb6, 0x14, 0xe3,
+	0x63, 0xb4, 0x21, 0xa4, 0xb0, 0x82, 0xe6, 0xa4, 0xa6, 0x39, 0x31, 0x60, 0xfd, 0x51, 0x38, 0x9a,
+	0x4e, 0xf6, 0xc2, 0xa1, 0x4e, 0xb3, 0x32, 0xa3, 0x17, 0x34, 0x17, 0x9c, 0x5a, 0xa5, 0xbf, 0x2d,
+	0x39, 0xb5, 0xd0, 0x75, 0xe8, 0x6e, 0x47, 0x7f, 0x41, 0xf3, 0x53, 0xb0, 0x07, 0xc7, 0xaf, 0x2e,
+	0x02, 0xef, 0xf5, 0x45, 0xe0, 0xfd, 0x7d, 0x11, 0x78, 0xbf, 0x5e, 0x06, 0x2b, 0xaf, 0x2f, 0x83,
+	0x95, 0x3f, 0x2e, 0x83, 0x95, 0xef, 0x9f, 0x2c, 0x84, 0xcd, 0xaa, 0x34, 0x62, 0xaa, 0x88, 0x99,
+	0x32, 0x85, 0x32, 0xf1, 0xf5, 0x5d, 0x3c, 0xbe, 0x5a, 0xf1, 0xf5, 0x7e, 0xfc, 0x93, 0xdb, 0xf3,
+	0x6e, 0x43, 0xa7, 0xab, 0xee, 0x8d, 0xef, 0xff, 0x13, 0x00, 0x00, 0xff, 0xff, 0xf7, 0x0b, 0x44,
+	0x31, 0x0f, 0x06, 0x00, 0x00,
 }
 
 func (m *ConsumerParams) Marshal() (dAtA []byte, err error) {