diff --git a/.changelog/unreleased/features/provider/2066-inactive-vals.md b/.changelog/unreleased/features/provider/2066-inactive-vals.md new file mode 100644 index 0000000000..f54d88fc29 --- /dev/null +++ b/.changelog/unreleased/features/provider/2066-inactive-vals.md @@ -0,0 +1 @@ +- Add the `allow_inactive_vals` parameter for consumer chains to choose whether inactive validators can validate their chain ([\#2066](https://github.com/cosmos/interchain-security/pull/2066)) \ No newline at end of file diff --git a/.changelog/unreleased/state-breaking/provider/2066-inactive-vals.md b/.changelog/unreleased/state-breaking/provider/2066-inactive-vals.md new file mode 100644 index 0000000000..f54d88fc29 --- /dev/null +++ b/.changelog/unreleased/state-breaking/provider/2066-inactive-vals.md @@ -0,0 +1 @@ +- Add the `allow_inactive_vals` parameter for consumer chains to choose whether inactive validators can validate their chain ([\#2066](https://github.com/cosmos/interchain-security/pull/2066)) \ No newline at end of file diff --git a/docs/docs/adrs/adr-017-allowing-inactive-validators.md b/docs/docs/adrs/adr-017-allowing-inactive-validators.md index 27c6d18b39..25ee270827 100644 --- a/docs/docs/adrs/adr-017-allowing-inactive-validators.md +++ b/docs/docs/adrs/adr-017-allowing-inactive-validators.md @@ -62,7 +62,10 @@ The following changes to the state are required: * Store the provider consensus validator set in the provider module state under the `LastProviderConsensusValsPrefix` key. This is the last set of validators that the provider sent to the consensus engine. This is needed to compute the ValUpdates to send to the consensus engine (by diffing the current set with this last sent set). * Increase the `MaxValidators` parameter of the staking module to the desired size of the potential validator set of consumer chains. -* Introduce two extra per-consumer-chain parameters: `MinStake` and `MaxValidatorRank`. `MinStake` is the minimum amount of stake a validator must have to be considered for validation on the consumer chain. `MaxValidatorRank` is the maximum rank of a validator that can validate on the consumer chain. The provider module will only consider the first `MaxValidatorRank` validators that have at least `MinStake` stake as potential validators for the consumer chain. +* Introduce extra per-consumer-chain parameters: + * `MinStake`: is the minimum amount of stake a validator must have to be considered for validation on the consumer chain. + * `MaxValidatorRank`: is the maximum rank in the provider validator set that can validate on the consumer chain. For example, setting this to 1 means only the validator with the most stake can validate on the consumer chain. + * `AllowInactiveVals`: is a boolean that determines whether validators that are not part of the active set on the provider chain can validate on the consumer chain. If this is set to `true`, validators outside the active set on the provider chain can validate on the consumer chain. If this is set to `true`, validators outside the active set on the provider chain cannot validate on the consumer chain. ## Risk Mitigations @@ -85,13 +88,17 @@ In the following, ### Scenario 1: Inactive validators should not be considered by governance Inactive validators should not be considered for the purpose of governance. -In particular, the governance module should not allow inactive validators to vote on proposals, -and the quorum depends only on the stake bonded by active validators. +In particular, the quorum should depend only on active validators. -This can be tested by creating a governance proposal, then trying to vote on it with inactive validators. -The proposal should not pass. -Afterwards, we create another proposal and vote on it with active validators, too. -Then, the proposal should pass. +We test this by: +* creating a provider chain (either with 3 active validators, or with only 1 active validator), a quorum of 50%, and 3 validators with alice=300, bob=299, charlie=299 stake +* we create a governance proposal +* alice votes for the proposal +* we check that the proposal has the right status: + * in the scenario where we have 3 active validators, the proposal *should not* have passed, because alice alone is not enough to fulfill the quorum + * in the scenario where we have 1 active validator, the proposal *should* have passed, because alice is the only active validator, and thus fulfills the quorum + +Tested by the e2e tests `inactive-provider-validators-governance` (scenario with 1 active val) and `inactive-provider-validators-governance-basecase` (scenario with 3 active vals). ### Scenario 2: Inactive validators should not get rewards from the provider chain @@ -99,20 +106,28 @@ Inactive validators should not get rewards from the provider chain. This can be tested by starting a provider chain with inactive validators and checking the rewards of inactive validators. +Checked as part of the e2e test `inactive-provider-validators-on-consumer`. + ### Scenario 3: Inactive validators should get rewards from consumer chains An inactive validator that is validating on a consumer chain should receive rewards in the consumer chain token. +Checked as part of the e2e test `inactive-provider-validators-on-consumer`. + ### Scenario 4: Inactive validators should not get slashed/jailed for downtime on the provider chain This can be tested by having an inactive validator go offline on the provider chain for long enough to accrue downtime. The validator should be neither slashed nor jailed for downtime. +Checked as part of the e2e test `inactive-provider-validators-on-consumer`. + ### Scenario 5: Inactive validators *should* get jailed for downtime on the provider chain This can be tested by having an inactive validator go offline on a consumer chain for long enough to accrue downtime. The consumer chain should send a SlashPacket to the provider chain, which should jail the validator. +Checked as part of the e2e test `inactive-provider-validators-on-consumer`. + ### Scenario 6: Inactive validators should not be counted when computing the minimum power in the top N This can be tested like this: @@ -122,7 +137,35 @@ This can be tested like this: * Without inactive validators, this means both alice and bob have to validate. But since charlie is inactive, this means bob is *not* in the top N * Verify that alice is in the top N, but bob is not -* **Mint**: +Checked as part of the e2e test `inactive-vals-topN`. + +### Scenario 7: Mint does not consider inactive validators + +To compute the inflation rate, only the active validators should be considered. + +We can check this by querying the inflation rate change over subsequent blocks. + +We start a provider chain with these arguments +* 3 validators with powers alice=290, bob=280, charlie=270 +* either 1 or 3 active validators +* a bonded goal of 300 tokens (this is given in percent, but we simplify here) + +If we have 3 validators active, then the inflation rate should *decrease* between blocks, because the bonded goal is exceeded as all validators are bonded. +If we have only 1 validator active, then the inflation rate should *increase* between blocks, because the bonded goal is not met. + +Checked as part of the e2e tests `inactive-vals-mint` (scenario with 1 active val) and `mint-basecase` (scenario with 3 active vals). + +### Scenarios 8: Inactive validators can validate on consumer chains + +An inactive validator can opt in and validate on consumer chains (if min stake and max rank allow it) + +Checked as part of the e2e test `inactive-provider-validators-on-consumer`. + +### Scenario 9: MinStake and MaxRank parameters are respected + +Validators that don't meet the criteria for a consumer chain cannot validate on it. + +Checked in the e2e tests `min-stake` and `max-rank`. ## Consequences diff --git a/docs/docs/features/power-shaping.md b/docs/docs/features/power-shaping.md index 8c952d239f..9d76300a82 100644 --- a/docs/docs/features/power-shaping.md +++ b/docs/docs/features/power-shaping.md @@ -32,9 +32,11 @@ power. For example, consider that the top validator `V` on the provider chain ha then if `V` is denylisted, the consumer chain would only be secured by at least 40% of the provider's power. ::: -1) **Maximum validator rank**: The consumer chain can specify a maximum position in the validator set that a validator can have on the provider chain to be able to validate the consumer chain. This can be used to ensure that only validators with relatively large amounts of stake can validate the consumer chain. For example, setting this to 20 would mean only the 20 validators with the most voting stake on the provider chain can validate the consumer chain. +4) **Maximum validator rank**: The consumer chain can specify a maximum position in the validator set that a validator can have on the provider chain to be able to validate the consumer chain. This can be used to ensure that only validators with relatively large amounts of stake can validate the consumer chain. For example, setting this to 20 would mean only the 20 validators with the most voting stake on the provider chain can validate the consumer chain. -2) **Minimum validator stake**: The consumer chain can specify a minimum amount of stake that a validator must have on the provider chain to be able to validate the consumer chain. This can be used to ensure that only validators with a certain amount of stake can validate the consumer chain. For example, setting this to 1000 would mean only validators with at least 1000 tokens staked on the provider chain can validate the consumer chain. +5) **Minimum validator stake**: The consumer chain can specify a minimum amount of stake that a validator must have on the provider chain to be able to validate the consumer chain. This can be used to ensure that only validators with a certain amount of stake can validate the consumer chain. For example, setting this to 1000 would mean only validators with at least 1000 tokens staked on the provider chain can validate the consumer chain. + +6) **Allow inactive validators**: The consumer chain can specify whether provider validators that are *not* active in consensus may validate on the consumer chain or not. If this is set to `false`, only active validators on the provider chain can validate the consumer chain. If this is set to `true`, inactive validators can also validate the consumer chain. This can be useful for chains that want to have a larger validator set than the active validators on the provider chain, or for chains that want to have a more decentralized validator set. COnsumer chains that enable this feature should strongly consider setting a maximum validator rank and/or a minimum validator stake to ensure that only validators with some reputation/stake can validate the chain. All these mechanisms are set by the consumer chain in the `ConsumerAdditionProposal`. They operate *solely on the provider chain*, meaning the consumer chain simply receives the validator set after these rules have been applied and does not have any knowledge about whether they are applied. @@ -43,6 +45,8 @@ Each of these mechanisms is *set during the consumer addition proposal* (see [On The values can be seen by querying the list of consumer chains: ```bash interchain-security-pd query provider list-consumer-chains + + ``` ## Guidelines for setting power shaping parameters diff --git a/proto/interchain_security/ccv/provider/v1/provider.proto b/proto/interchain_security/ccv/provider/v1/provider.proto index eb664e2917..390de31224 100644 --- a/proto/interchain_security/ccv/provider/v1/provider.proto +++ b/proto/interchain_security/ccv/provider/v1/provider.proto @@ -110,6 +110,8 @@ message ConsumerAdditionProposal { uint64 min_stake = 20; // Corresponds to the maximal rank in the provider chain validator set that a validator can have to validate on the consumer chain. uint32 max_rank = 21; + // Corresponds to whether inactive validators are allowed to validate the consumer chain. + bool allow_inactive_vals = 22; } // ConsumerRemovalProposal is a governance proposal on the provider chain to @@ -164,6 +166,8 @@ message ConsumerModificationProposal { uint64 min_stake = 9; // Corresponds to the maximal rank in the provider chain validator set that a validator can have to validate on the consumer chain. uint32 max_rank = 10; + // Corresponds to whether inactive validators are allowed to validate the consumer chain. + bool allow_inactive_vals = 11; } diff --git a/proto/interchain_security/ccv/provider/v1/tx.proto b/proto/interchain_security/ccv/provider/v1/tx.proto index 6a9d52707e..8440bf6a4f 100644 --- a/proto/interchain_security/ccv/provider/v1/tx.proto +++ b/proto/interchain_security/ccv/provider/v1/tx.proto @@ -187,6 +187,8 @@ message MsgConsumerAddition { uint64 min_stake = 19; // Corresponds to the maximal rank in the provider chain validator set that a validator can have to validate on the consumer chain. uint32 max_rank = 20; + // Corresponds to whether inactive validators are allowed to validate the consumer chain. + bool allow_inactive_vals = 21; } // MsgConsumerAdditionResponse defines response type for MsgConsumerAddition messages @@ -328,6 +330,8 @@ message MsgConsumerModification { uint64 min_stake = 10; // Corresponds to the maximal rank in the provider chain validator set that a validator can have to validate on the consumer chain. uint32 max_rank = 11; + // Corresponds to whether inactive validators are allowed to validate the consumer chain. + bool allow_inactive_vals = 12; } message MsgConsumerModificationResponse {} diff --git a/tests/e2e/actions.go b/tests/e2e/actions.go index f50f23b41a..b52f5b73c7 100644 --- a/tests/e2e/actions.go +++ b/tests/e2e/actions.go @@ -263,6 +263,9 @@ type SubmitConsumerAdditionProposalAction struct { ValidatorSetCap uint32 Allowlist []string Denylist []string + MaxValidatorRank uint32 + MinStake uint64 + AllowInactiveVals bool } func (tr Chain) submitConsumerAdditionProposal( @@ -292,6 +295,9 @@ func (tr Chain) submitConsumerAdditionProposal( ValidatorSetCap: action.ValidatorSetCap, Allowlist: action.Allowlist, Denylist: action.Denylist, + MaxValidatorRank: action.MaxValidatorRank, + MinStake: action.MinStake, + AllowInactiveVals: action.AllowInactiveVals, } bz, err := json.Marshal(prop) @@ -334,7 +340,6 @@ func (tr Chain) submitConsumerAdditionProposal( fmt.Println("submitConsumerAdditionProposal json:", jsonStr) } bz, err = cmd.CombinedOutput() - if err != nil { log.Fatal(err, "\n", string(bz)) } @@ -468,7 +473,6 @@ func (tr Chain) submitConsumerModificationProposal( } bz, err = cmd.CombinedOutput() - if err != nil { log.Fatal(err, "\n", string(bz)) } @@ -1005,7 +1009,6 @@ func (tr Chain) addChainToHermes( action AddChainToRelayerAction, verbose bool, ) { - bz, err := tr.target.ExecCommand("bash", "-c", "hermes", "version").CombinedOutput() if err != nil { log.Fatal(err, "\n error getting hermes version", string(bz)) @@ -1911,7 +1914,7 @@ func (tr Chain) registerRepresentative( panic(fmt.Sprintf("failed writing ccv consumer file : %v", err)) } defer file.Close() - err = os.WriteFile(file.Name(), []byte(fileContent), 0600) + err = os.WriteFile(file.Name(), []byte(fileContent), 0o600) if err != nil { log.Fatalf("Failed writing consumer genesis to file: %v", err) } diff --git a/tests/e2e/config.go b/tests/e2e/config.go index 19fca5da88..2296a07b8e 100644 --- a/tests/e2e/config.go +++ b/tests/e2e/config.go @@ -93,6 +93,10 @@ const ( CompatibilityTestCfg TestConfigType = "compatibility" SmallMaxValidatorsTestCfg TestConfigType = "small-max-validators" InactiveProviderValsTestCfg TestConfigType = "inactive-provider-vals" + GovTestCfg TestConfigType = "gov" + InactiveValsGovTestCfg TestConfigType = "inactive-vals-gov" + InactiveValsMintTestCfg TestConfigType = "inactive-vals-mint" + MintTestCfg TestConfigType = "mint" ) type TestConfig struct { @@ -183,6 +187,14 @@ func GetTestConfig(cfgType TestConfigType, providerVersion, consumerVersion stri testCfg = SmallMaxValidatorsTestConfig() case InactiveProviderValsTestCfg: testCfg = InactiveProviderValsTestConfig() + case GovTestCfg: + testCfg = GovTestConfig() + case InactiveValsGovTestCfg: + testCfg = InactiveValsGovTestConfig() + case InactiveValsMintTestCfg: + testCfg = InactiveValsMintTestConfig() + case MintTestCfg: + testCfg = MintTestConfig() default: panic(fmt.Sprintf("Invalid test config: %s", cfgType)) } @@ -573,7 +585,7 @@ func InactiveProviderValsTestConfig() TestConfig { tr.chainConfigs[ChainID("provi")] = proviConfig tr.chainConfigs[ChainID("consu")] = consuConfig - // make is to that carol does not use a consumer key + // make it so that carol does not use a consumer key carolConfig := tr.validatorConfigs[ValidatorID("carol")] carolConfig.UseConsumerKey = false tr.validatorConfigs[ValidatorID("carol")] = carolConfig @@ -597,6 +609,60 @@ func SmallMaxValidatorsTestConfig() TestConfig { return cfg } +func GovTestConfig() TestConfig { + cfg := DefaultTestConfig() + + // set the quorum to 50% + proviConfig := cfg.chainConfigs[ChainID("provi")] + proviConfig.GenesisChanges += "| .app_state.gov.params.quorum = \"0.5\"" + cfg.chainConfigs[ChainID("provi")] = proviConfig + + carolConfig := cfg.validatorConfigs["carol"] + // make carol use her own key + carolConfig.UseConsumerKey = false + cfg.validatorConfigs["carol"] = carolConfig + + return cfg +} + +func InactiveValsGovTestConfig() TestConfig { + cfg := GovTestConfig() + + // set the MaxValidators to 1 + proviConfig := cfg.chainConfigs[ChainID("provi")] + proviConfig.GenesisChanges += "| .app_state.staking.params.max_validators = 1" + cfg.chainConfigs[ChainID("provi")] = proviConfig + + return cfg +} + +func MintTestConfig() TestConfig { + cfg := GovTestConfig() + AdjustMint(cfg) + + return cfg +} + +func InactiveValsMintTestConfig() TestConfig { + cfg := InactiveValsGovTestConfig() + AdjustMint(cfg) + + return cfg +} + +// AdjustMint adjusts the mint parameters to have a very low goal bonded amount +// and a high inflation rate change +func AdjustMint(cfg TestConfig) { + proviConfig := cfg.chainConfigs[ChainID("provi")] + // total supply is 30000000000stake; we want to set the mint bonded goal to + // a small fraction of that + proviConfig.GenesisChanges += "| .app_state.mint.params.goal_bonded = \"0.001\"" + + "| .app_state.mint.params.inflation_rate_change = \"1\"" + + "| .app_state.mint.params.inflation_max = \"0.5\"" + + "| .app_state.mint.params.inflation_min = \"0.1\"" + cfg.chainConfigs[ChainID("provi")] = proviConfig +} + func MultiConsumerTestConfig() TestConfig { tr := TestConfig{ name: string(MulticonsumerTestCfg), diff --git a/tests/e2e/main.go b/tests/e2e/main.go index 6b7f3a2db1..1f73d68ed7 100644 --- a/tests/e2e/main.go +++ b/tests/e2e/main.go @@ -216,6 +216,42 @@ var stepChoices = map[string]StepChoice{ description: "test inactive validators on topN chain", testConfig: InactiveProviderValsTestCfg, }, + "inactive-provider-validators-governance": { + name: "inactive-provider-validators-governance", + steps: stepsInactiveProviderValidatorsGovernance(), + description: "test governance with inactive validators", + testConfig: InactiveValsGovTestCfg, + }, + "inactive-provider-validators-governance-basecase": { + name: "inactive-provider-validators-governance-basecase", + steps: stepsInactiveProviderValidatorsGovernanceBasecase(), + description: "comparison for governance when there are *no* inactive validators, to verify the difference to the governance test *with* inactive validators", + testConfig: GovTestCfg, + }, + "max-rank": { + name: "max-rank", + steps: stepsMaxRank(), + description: "checks that the max rank parameter for consumer chains is respected", + testConfig: GovTestCfg, // can reuse the GovTestCfg because all parameters there are ok to use here + }, + "min-stake": { + name: "min-stake", + steps: stepsMinStake(), + description: "checks that the min stake parameter for consumer chains is respected", + testConfig: GovTestCfg, // see above: we reuse the GovTestCfg for convenience + }, + "inactive-vals-mint": { + name: "inactive-vals-mint", + steps: stepsInactiveValsMint(), + description: "test minting with inactive validators", + testConfig: InactiveValsMintTestCfg, + }, + "mint-basecase": { + name: "mint-basecase", + steps: stepsMintBasecase(), + description: "test minting without inactive validators as a sanity check", + testConfig: MintTestCfg, + }, } func getTestCaseUsageString() string { @@ -306,6 +342,8 @@ func getTestCases(selectedPredefinedTests, selectedTestFiles TestSet, providerVe "partial-set-security-validators-allowlisted", "partial-set-security-validators-denylisted", "partial-set-security-modification-proposal", "active-set-changes", "inactive-vals-topN", + "inactive-provider-validators-on-consumer", "inactive-provider-validators-governance", + "max-rank", "min-stake", "inactive-vals-mint", } if includeMultiConsumer != nil && *includeMultiConsumer { selectedPredefinedTests = append(selectedPredefinedTests, "multiconsumer") diff --git a/tests/e2e/state.go b/tests/e2e/state.go index 4e5959898c..3caee9ce5c 100644 --- a/tests/e2e/state.go +++ b/tests/e2e/state.go @@ -116,6 +116,29 @@ func (tr Chain) GetChainState(chain ChainID, modelState ChainState) ChainState { chainState.HasToValidate = &hasToValidate } + if modelState.InflationRateChange != nil { + // get the inflation rate now + inflationRateNow := tr.target.GetInflationRate(chain) + + // wait a block + tr.waitBlocks(chain, 1, 10*time.Second) + + // get the new inflation rate + inflationRateAfter := tr.target.GetInflationRate(chain) + + // calculate the change + inflationRateChange := inflationRateAfter - inflationRateNow + var inflationRateChangeDirection int + if inflationRateChange > 0 { + inflationRateChangeDirection = 1 + } else if inflationRateChange < 0 { + inflationRateChangeDirection = -1 + } else { + inflationRateChangeDirection = 0 + } + chainState.InflationRateChange = &inflationRateChangeDirection + } + if modelState.ConsumerPendingPacketQueueSize != nil { pendingPacketQueueSize := tr.target.GetPendingPacketQueueSize(chain) chainState.ConsumerPendingPacketQueueSize = &pendingPacketQueueSize @@ -302,6 +325,10 @@ func uintPtr(i uint) *uint { return &i } +func intPtr(i int) *int { + return &i +} + type Commands struct { containerConfig ContainerConfig // FIXME only needed for 'Now' time tracking validatorConfigs map[ValidatorID]ValidatorConfig @@ -867,6 +894,23 @@ func (tr Commands) GetHasToValidate( return chains } +func (tr Commands) GetInflationRate( + chain ChainID, +) float64 { + binaryName := tr.chainConfigs[chain].BinaryName + bz, err := tr.target.ExecCommand(binaryName, + "query", "mint", "inflation", + `--node`, tr.GetQueryNode(chain), + `-o`, `json`, + ).CombinedOutput() + if err != nil { + log.Fatal(err, "\n", string(bz)) + } + + inflationRate := gjson.Get(string(bz), "inflation").Float() + return inflationRate +} + func (tr Commands) GetTrustedHeight( chain ChainID, clientID string, diff --git a/tests/e2e/steps_inactive_vals.go b/tests/e2e/steps_inactive_vals.go index 7f3c75b800..1fb145e47c 100644 --- a/tests/e2e/steps_inactive_vals.go +++ b/tests/e2e/steps_inactive_vals.go @@ -352,16 +352,17 @@ func stepsInactiveProviderValidators() []Step { // Postcondition: A consumer chain with Top N = 0 is running, including an up-and-running IBC connection to the provider. // "alice", "bob", "carol" have opted in and are validating. func setupOptInChain() []Step { - return []Step{ + return concatSteps([]Step{ { Action: SubmitConsumerAdditionProposalAction{ - Chain: ChainID("provi"), - From: ValidatorID("alice"), - Deposit: 10000001, - ConsumerChain: ChainID("consu"), - SpawnTime: 0, - InitialHeight: clienttypes.Height{RevisionNumber: 0, RevisionHeight: 1}, - TopN: 0, + Chain: ChainID("provi"), + From: ValidatorID("alice"), + Deposit: 10000001, + ConsumerChain: ChainID("consu"), + SpawnTime: 0, + InitialHeight: clienttypes.Height{RevisionNumber: 0, RevisionHeight: 1}, + TopN: 0, + AllowInactiveVals: true, }, State: State{ ChainID("provi"): ChainState{ @@ -382,124 +383,498 @@ func setupOptInChain() []Step { }, }, }, + }, + stepsOptInValidators("alice", "bob", "carol"), + []Step{ + { + Action: VoteGovProposalAction{ + Chain: ChainID("provi"), + From: []ValidatorID{ValidatorID("alice"), ValidatorID("bob")}, + Vote: []string{"yes", "yes"}, + PropNumber: 1, + }, + State: State{ + ChainID("provi"): ChainState{ + Proposals: &map[uint]Proposal{ + 1: ConsumerAdditionProposal{ + Deposit: 10000001, + Chain: ChainID("consu"), + SpawnTime: 0, + InitialHeight: clienttypes.Height{RevisionNumber: 0, RevisionHeight: 1}, + Status: strconv.Itoa(int(gov.ProposalStatus_PROPOSAL_STATUS_PASSED)), + }, + }, + }, + }, + }, + { + // we start all the validators but only "alice" and "bob" have opted in and hence + // only "alice" and "bob" are validating blocks + Action: StartConsumerChainAction{ + ConsumerChain: ChainID("consu"), + ProviderChain: ChainID("provi"), + Validators: []StartChainValidator{ + {Id: ValidatorID("alice"), Stake: 100000000, Allocation: 10000000000}, + {Id: ValidatorID("bob"), Stake: 200000000, Allocation: 10000000000}, + {Id: ValidatorID("carol"), Stake: 300000000, Allocation: 10000000000}, + }, + // For consumers that're launching with the provider being on an earlier version + // of ICS before the soft opt-out threshold was introduced, we need to set the + // soft opt-out threshold to 0.05 in the consumer genesis to ensure that the + // consumer binary doesn't panic. Sdk requires that all params are set to valid + // values from the genesis file. + GenesisChanges: ".app_state.ccvconsumer.params.soft_opt_out_threshold = \"0.05\"", + }, + State: State{ + ChainID("consu"): ChainState{ + ValPowers: &map[ValidatorID]uint{ + ValidatorID("alice"): 100, + ValidatorID("bob"): 200, + ValidatorID("carol"): 300, + }, + }, + }, + }, + { + Action: AddIbcConnectionAction{ + ChainA: ChainID("consu"), + ChainB: ChainID("provi"), + ClientA: 0, + ClientB: 0, + }, + State: State{}, + }, + { + Action: AddIbcChannelAction{ + ChainA: ChainID("consu"), + ChainB: ChainID("provi"), + ConnectionA: 0, + PortA: "consumer", + PortB: "provider", + Order: "ordered", + }, + State: State{}, + }, + }, + ) +} + +func stepsOptInValidators(validators ...ValidatorID) []Step { + s := make([]Step, 0) + for _, val := range validators { // Οpt in all validators - { + s = append(s, Step{ Action: OptInAction{ Chain: ChainID("consu"), - Validator: ValidatorID("alice"), + Validator: val, }, State: State{ - ChainID("provi"): ChainState{ - HasToValidate: &map[ValidatorID][]ChainID{ - ValidatorID("alice"): {}, // chain is not running yet - ValidatorID("bob"): {}, - ValidatorID("carol"): {}, + ChainID("provi"): ChainState{}, + }, + }, + ) + } + return s +} + +// stepsInactiveProviderValidatorsGovernance validates that inactive validators +// are not included in the calculation of the quorum for governance proposals. +// It checks that when the quorum is met *among active validators*, +// the proposal can pass, even though the quorum would not be met if inactive validators +// would be counted. +func stepsInactiveProviderValidatorsGovernance() []Step { + s := concatSteps( + []Step{ + { + Action: StartChainAction{ + Chain: ChainID("provi"), + Validators: []StartChainValidator{ + {Id: ValidatorID("alice"), Stake: 290000000, Allocation: 10000000000}, + {Id: ValidatorID("bob"), Stake: 290000000, Allocation: 10000000000}, + {Id: ValidatorID("carol"), Stake: 300000000, Allocation: 10000000000}, + }, + }, + State: State{ + ChainID("provi"): ChainState{ + ValPowers: &map[ValidatorID]uint{ + ValidatorID("alice"): 0, // max consensus validators is 1, so alice and bob should not be in power + ValidatorID("bob"): 0, + ValidatorID("carol"): 300, + }, + StakedTokens: &map[ValidatorID]uint{ + ValidatorID("alice"): 290000000, + ValidatorID("bob"): 290000000, + ValidatorID("carol"): 300000000, + }, }, }, }, }, - { - Action: OptInAction{ - Chain: ChainID("consu"), - Validator: ValidatorID("bob"), + []Step{ + // create a governance proposal + { + Action: SubmitConsumerAdditionProposalAction{ + Chain: ChainID("provi"), + From: ValidatorID("alice"), + Deposit: 10000001, + ConsumerChain: ChainID("consu"), + SpawnTime: 0, + InitialHeight: clienttypes.Height{RevisionNumber: 0, RevisionHeight: 1}, + TopN: 51, + }, + State: State{ + ChainID("provi"): ChainState{ + Proposals: &map[uint]Proposal{ + 1: ConsumerAdditionProposal{ + Deposit: 10000001, + Chain: ChainID("consu"), + SpawnTime: 0, + InitialHeight: clienttypes.Height{RevisionNumber: 0, RevisionHeight: 1}, + Status: strconv.Itoa(int(gov.ProposalStatus_PROPOSAL_STATUS_VOTING_PERIOD)), + }, + }, + }, + }, }, - State: State{ - ChainID("provi"): ChainState{ - HasToValidate: &map[ValidatorID][]ChainID{ - ValidatorID("alice"): {}, - ValidatorID("bob"): {}, - ValidatorID("carol"): {}, + // vote for it with carol + { + Action: VoteGovProposalAction{ + Chain: ChainID("provi"), + From: []ValidatorID{ValidatorID("carol")}, + Vote: []string{"yes"}, + PropNumber: 1, + }, + State: State{ + ChainID("provi"): ChainState{ + Proposals: &map[uint]Proposal{ + 1: ConsumerAdditionProposal{ + Deposit: 10000001, + Chain: ChainID("consu"), + SpawnTime: 0, + InitialHeight: clienttypes.Height{RevisionNumber: 0, RevisionHeight: 1}, + // the proposal should have passed because carol voted for it. + // carol alone is enough to pass the quorum, because stake of the other validators is not counted + Status: strconv.Itoa(int(gov.ProposalStatus_PROPOSAL_STATUS_PASSED)), + }, + }, }, }, }, }, - { - Action: OptInAction{ - Chain: ChainID("consu"), - Validator: ValidatorID("carol"), + ) + + return s +} + +// stepsInactiveProviderValidatorsGovernanceBasecase is a sanity check to go along with +// stepsInactiveProviderValidatorsGovernance. It tests that with all validators being active, +// the proposal does not pass if it does not meet the quorum among validators. +func stepsInactiveProviderValidatorsGovernanceBasecase() []Step { + s := concatSteps( + []Step{ + { + Action: StartChainAction{ + Chain: ChainID("provi"), + Validators: []StartChainValidator{ + {Id: ValidatorID("alice"), Stake: 290000000, Allocation: 10000000000}, + {Id: ValidatorID("bob"), Stake: 290000000, Allocation: 10000000000}, + {Id: ValidatorID("carol"), Stake: 300000000, Allocation: 10000000000}, + }, + }, + State: State{ + ChainID("provi"): ChainState{ + ValPowers: &map[ValidatorID]uint{ + ValidatorID("alice"): 290, + ValidatorID("bob"): 290, + ValidatorID("carol"): 300, + }, + StakedTokens: &map[ValidatorID]uint{ + ValidatorID("alice"): 290000000, + ValidatorID("bob"): 290000000, + ValidatorID("carol"): 300000000, + }, + }, + }, }, - State: State{ - ChainID("provi"): ChainState{ - HasToValidate: &map[ValidatorID][]ChainID{ - ValidatorID("alice"): {}, - ValidatorID("bob"): {}, - ValidatorID("carol"): {}, + }, + []Step{ + // create a governance proposal + { + Action: SubmitConsumerAdditionProposalAction{ + Chain: ChainID("provi"), + From: ValidatorID("alice"), + Deposit: 10000001, + ConsumerChain: ChainID("consu"), + SpawnTime: 0, + InitialHeight: clienttypes.Height{RevisionNumber: 0, RevisionHeight: 1}, + TopN: 51, + }, + State: State{ + ChainID("provi"): ChainState{ + Proposals: &map[uint]Proposal{ + 1: ConsumerAdditionProposal{ + Deposit: 10000001, + Chain: ChainID("consu"), + SpawnTime: 0, + InitialHeight: clienttypes.Height{RevisionNumber: 0, RevisionHeight: 1}, + Status: strconv.Itoa(int(gov.ProposalStatus_PROPOSAL_STATUS_VOTING_PERIOD)), + }, + }, + }, + }, + }, + // vote for it with carol + { + Action: VoteGovProposalAction{ + Chain: ChainID("provi"), + From: []ValidatorID{ValidatorID("carol")}, + Vote: []string{"yes"}, + PropNumber: 1, + }, + State: State{ + ChainID("provi"): ChainState{ + Proposals: &map[uint]Proposal{ + 1: ConsumerAdditionProposal{ + Deposit: 10000001, + Chain: ChainID("consu"), + SpawnTime: 0, + InitialHeight: clienttypes.Height{RevisionNumber: 0, RevisionHeight: 1}, + // the proposal should *not* have passed because only carol voted for it, + // and carol is not enough to pass the quorum + Status: strconv.Itoa(int(gov.ProposalStatus_PROPOSAL_STATUS_REJECTED)), + }, + }, }, }, }, }, - { - Action: VoteGovProposalAction{ - Chain: ChainID("provi"), - From: []ValidatorID{ValidatorID("alice"), ValidatorID("bob")}, - Vote: []string{"yes", "yes"}, - PropNumber: 1, + ) + + return s +} + +// stepsMaxRank validates that a validator with a rank higher than the specified maxRank parameter +// cannot validate the consumer chain. +func stepsMaxRank() []Step { + return concatSteps( + []Step{ + { + Action: StartChainAction{ + Chain: ChainID("provi"), + Validators: []StartChainValidator{ + {Id: ValidatorID("alice"), Stake: 290000000, Allocation: 10000000000}, + {Id: ValidatorID("bob"), Stake: 290000000, Allocation: 10000000000}, + {Id: ValidatorID("carol"), Stake: 300000000, Allocation: 10000000000}, + }, + }, + State: State{ + ChainID("provi"): ChainState{ + ValPowers: &map[ValidatorID]uint{ + ValidatorID("alice"): 290, + ValidatorID("bob"): 290, + ValidatorID("carol"): 300, + }, + StakedTokens: &map[ValidatorID]uint{ + ValidatorID("alice"): 290000000, + ValidatorID("bob"): 290000000, + ValidatorID("carol"): 300000000, + }, + }, + }, }, - State: State{ - ChainID("provi"): ChainState{ - Proposals: &map[uint]Proposal{ - 1: ConsumerAdditionProposal{ - Deposit: 10000001, - Chain: ChainID("consu"), - SpawnTime: 0, - InitialHeight: clienttypes.Height{RevisionNumber: 0, RevisionHeight: 1}, - Status: strconv.Itoa(int(gov.ProposalStatus_PROPOSAL_STATUS_PASSED)), + // create a governance proposal + { + Action: SubmitConsumerAdditionProposalAction{ + Chain: ChainID("provi"), + From: ValidatorID("alice"), + Deposit: 10000001, + ConsumerChain: ChainID("consu"), + SpawnTime: 0, + InitialHeight: clienttypes.Height{RevisionNumber: 0, RevisionHeight: 1}, + TopN: 0, + MaxValidatorRank: 1, + }, + State: State{ + ChainID("provi"): ChainState{ + Proposals: &map[uint]Proposal{ + 1: ConsumerAdditionProposal{ + Deposit: 10000001, + Chain: ChainID("consu"), + SpawnTime: 0, + InitialHeight: clienttypes.Height{RevisionNumber: 0, RevisionHeight: 1}, + Status: strconv.Itoa(int(gov.ProposalStatus_PROPOSAL_STATUS_VOTING_PERIOD)), + }, }, }, }, }, }, - { - // we start all the validators but only "alice" and "bob" have opted in and hence - // only "alice" and "bob" are validating blocks - Action: StartConsumerChainAction{ - ConsumerChain: ChainID("consu"), - ProviderChain: ChainID("provi"), - Validators: []StartChainValidator{ - {Id: ValidatorID("alice"), Stake: 100000000, Allocation: 10000000000}, - {Id: ValidatorID("bob"), Stake: 200000000, Allocation: 10000000000}, - {Id: ValidatorID("carol"), Stake: 300000000, Allocation: 10000000000}, + stepsOptInValidators("alice", "bob", "carol"), + []Step{ + { + Action: VoteGovProposalAction{ + Chain: ChainID("provi"), + From: []ValidatorID{ValidatorID("alice"), ValidatorID("bob")}, + Vote: []string{"yes", "yes"}, + PropNumber: 1, + }, + State: State{ + ChainID("provi"): ChainState{ + Proposals: &map[uint]Proposal{ + 1: ConsumerAdditionProposal{ + Deposit: 10000001, + Chain: ChainID("consu"), + SpawnTime: 0, + InitialHeight: clienttypes.Height{RevisionNumber: 0, RevisionHeight: 1}, + Status: strconv.Itoa(int(gov.ProposalStatus_PROPOSAL_STATUS_PASSED)), + }, + }, + }, }, - // For consumers that're launching with the provider being on an earlier version - // of ICS before the soft opt-out threshold was introduced, we need to set the - // soft opt-out threshold to 0.05 in the consumer genesis to ensure that the - // consumer binary doesn't panic. Sdk requires that all params are set to valid - // values from the genesis file. - GenesisChanges: ".app_state.ccvconsumer.params.soft_opt_out_threshold = \"0.05\"", }, - State: State{ - ChainID("consu"): ChainState{ - ValPowers: &map[ValidatorID]uint{ - ValidatorID("alice"): 100, - ValidatorID("bob"): 200, - ValidatorID("carol"): 300, + { + // we start all the validators, but due to max rank of 1, only carol can validate + Action: StartConsumerChainAction{ + ConsumerChain: ChainID("consu"), + ProviderChain: ChainID("provi"), + Validators: []StartChainValidator{ + {Id: ValidatorID("alice"), Stake: 100000000, Allocation: 10000000000}, + {Id: ValidatorID("bob"), Stake: 200000000, Allocation: 10000000000}, + {Id: ValidatorID("carol"), Stake: 300000000, Allocation: 10000000000}, + }, + // For consumers that're launching with the provider being on an earlier version + // of ICS before the soft opt-out threshold was introduced, we need to set the + // soft opt-out threshold to 0.05 in the consumer genesis to ensure that the + // consumer binary doesn't panic. Sdk requires that all params are set to valid + // values from the genesis file. + GenesisChanges: ".app_state.ccvconsumer.params.soft_opt_out_threshold = \"0.05\"", + }, + State: State{ + ChainID("consu"): ChainState{ + ValPowers: &map[ValidatorID]uint{ + ValidatorID("alice"): 0, + ValidatorID("bob"): 0, + ValidatorID("carol"): 300, // due to max rank of 1, only carol can validate + }, }, }, }, }, - { - Action: AddIbcConnectionAction{ - ChainA: ChainID("consu"), - ChainB: ChainID("provi"), - ClientA: 0, - ClientB: 0, + ) +} + +// stepsMinStake validates that a validator with less stake than the specified minStake parameter +// cannot validate the consumer chain. +func stepsMinStake() []Step { + return concatSteps( + []Step{ + { + Action: StartChainAction{ + Chain: ChainID("provi"), + Validators: []StartChainValidator{ + {Id: ValidatorID("alice"), Stake: 290000000, Allocation: 10000000000}, + {Id: ValidatorID("bob"), Stake: 290000000, Allocation: 10000000000}, + {Id: ValidatorID("carol"), Stake: 300000000, Allocation: 10000000000}, + }, + }, + State: State{ + ChainID("provi"): ChainState{ + ValPowers: &map[ValidatorID]uint{ + ValidatorID("alice"): 290, + ValidatorID("bob"): 290, + ValidatorID("carol"): 300, + }, + StakedTokens: &map[ValidatorID]uint{ + ValidatorID("alice"): 290000000, + ValidatorID("bob"): 290000000, + ValidatorID("carol"): 300000000, + }, + }, + }, + }, + // create a governance proposal + { + Action: SubmitConsumerAdditionProposalAction{ + Chain: ChainID("provi"), + From: ValidatorID("alice"), + Deposit: 10000001, + ConsumerChain: ChainID("consu"), + SpawnTime: 0, + InitialHeight: clienttypes.Height{RevisionNumber: 0, RevisionHeight: 1}, + TopN: 0, + MinStake: 300000000, + }, + State: State{ + ChainID("provi"): ChainState{ + Proposals: &map[uint]Proposal{ + 1: ConsumerAdditionProposal{ + Deposit: 10000001, + Chain: ChainID("consu"), + SpawnTime: 0, + InitialHeight: clienttypes.Height{RevisionNumber: 0, RevisionHeight: 1}, + Status: strconv.Itoa(int(gov.ProposalStatus_PROPOSAL_STATUS_VOTING_PERIOD)), + }, + }, + }, + }, }, - State: State{}, }, - { - Action: AddIbcChannelAction{ - ChainA: ChainID("consu"), - ChainB: ChainID("provi"), - ConnectionA: 0, - PortA: "consumer", - PortB: "provider", - Order: "ordered", - }, - State: State{}, + stepsOptInValidators("alice", "bob", "carol"), + []Step{ + { + Action: VoteGovProposalAction{ + Chain: ChainID("provi"), + From: []ValidatorID{ValidatorID("alice"), ValidatorID("bob")}, + Vote: []string{"yes", "yes"}, + PropNumber: 1, + }, + State: State{ + ChainID("provi"): ChainState{ + Proposals: &map[uint]Proposal{ + 1: ConsumerAdditionProposal{ + Deposit: 10000001, + Chain: ChainID("consu"), + SpawnTime: 0, + InitialHeight: clienttypes.Height{RevisionNumber: 0, RevisionHeight: 1}, + Status: strconv.Itoa(int(gov.ProposalStatus_PROPOSAL_STATUS_PASSED)), + }, + }, + }, + }, + }, + { + // we start all the validators, but due to max rank of 1, only carol can validate + Action: StartConsumerChainAction{ + ConsumerChain: ChainID("consu"), + ProviderChain: ChainID("provi"), + Validators: []StartChainValidator{ + {Id: ValidatorID("alice"), Stake: 100000000, Allocation: 10000000000}, + {Id: ValidatorID("bob"), Stake: 200000000, Allocation: 10000000000}, + {Id: ValidatorID("carol"), Stake: 300000000, Allocation: 10000000000}, + }, + // For consumers that're launching with the provider being on an earlier version + // of ICS before the soft opt-out threshold was introduced, we need to set the + // soft opt-out threshold to 0.05 in the consumer genesis to ensure that the + // consumer binary doesn't panic. Sdk requires that all params are set to valid + // values from the genesis file. + GenesisChanges: ".app_state.ccvconsumer.params.soft_opt_out_threshold = \"0.05\"", + }, + State: State{ + ChainID("consu"): ChainState{ + ValPowers: &map[ValidatorID]uint{ + ValidatorID("alice"): 0, + ValidatorID("bob"): 0, + ValidatorID("carol"): 300, // due to min stake of 300000000, only carol can validate + }, + }, + }, + }, }, - } + ) } +// This test case validates that inactive validators are not included when computing +// the top N. func stepsInactiveValsWithTopN() []Step { return []Step{ { @@ -615,3 +990,96 @@ func stepsInactiveValsWithTopN() []Step { }, } } + +// stepsInactiveValsMint tests the minting of tokens with inactive validators +// It checks that inactive validators are not counted when computing whether the +// inflation rate should go up or down. +func stepsInactiveValsMint() []Step { + // total supply is 30000000000, bonded goal ratio makes it so we want 30000000 tokens bonded + return []Step{ + { + Action: StartChainAction{ + Chain: ChainID("provi"), + Validators: []StartChainValidator{ + {Id: ValidatorID("alice"), Stake: 27000000, Allocation: 10000000000}, + {Id: ValidatorID("bob"), Stake: 28000000, Allocation: 10000000000}, + {Id: ValidatorID("carol"), Stake: 29000000, Allocation: 10000000000}, + }, + }, + State: State{ + ChainID("provi"): ChainState{ + ValPowers: &map[ValidatorID]uint{ + ValidatorID("alice"): 0, + ValidatorID("bob"): 0, + ValidatorID("carol"): 29, // other validators are not in power since only 1 can be active + }, + InflationRateChange: intPtr(1), // inflation rate goes up because less than the goal is bonded, since only carol is active + }, + }, + }, + { + Action: DelegateTokensAction{ + Chain: ChainID("provi"), + From: ValidatorID("carol"), + To: ValidatorID("carol"), + Amount: 50000000, + }, + State: State{ + ChainID("provi"): ChainState{ + ValPowers: &map[ValidatorID]uint{ + ValidatorID("alice"): 0, + ValidatorID("bob"): 0, + ValidatorID("carol"): 79, + }, + InflationRateChange: intPtr(-1), // inflation rate goes down now, because carol has more bonded than the goal + }, + }, + }, + } +} + +// stepsMintBasecase tests the minting of tokens without inactive validators. +// This is done as a sanity check to complement stepsInactiveValsMint. +func stepsMintBasecase() []Step { + // total supply is 30000000000, bonded goal ratio makes it so we want 30000000 tokens bonded + return []Step{ + { + Action: StartChainAction{ + Chain: ChainID("provi"), + Validators: []StartChainValidator{ + {Id: ValidatorID("alice"), Stake: 27000000, Allocation: 10000000000}, + {Id: ValidatorID("bob"), Stake: 28000000, Allocation: 10000000000}, + {Id: ValidatorID("carol"), Stake: 29000000, Allocation: 10000000000}, + }, + }, + State: State{ + ChainID("provi"): ChainState{ + ValPowers: &map[ValidatorID]uint{ + ValidatorID("alice"): 27, + ValidatorID("bob"): 28, + ValidatorID("carol"): 29, + }, + InflationRateChange: intPtr(-1), // inflation rate goes down because more than the goal is bonded + }, + }, + }, + { + Action: DelegateTokensAction{ + Chain: ChainID("provi"), + From: ValidatorID("carol"), + To: ValidatorID("carol"), + Amount: 50000000, + }, + State: State{ + ChainID("provi"): ChainState{ + ValPowers: &map[ValidatorID]uint{ + ValidatorID("alice"): 27, + ValidatorID("bob"): 28, + ValidatorID("carol"): 79, + }, + InflationRateChange: intPtr(-1), // inflation rate *still* goes down + }, + }, + }, + } +} diff --git a/tests/e2e/testlib/types.go b/tests/e2e/testlib/types.go index 135f07a6a8..725c4e6951 100644 --- a/tests/e2e/testlib/types.go +++ b/tests/e2e/testlib/types.go @@ -37,6 +37,7 @@ type ChainCommands interface { GetValPower(chain ChainID, validator ValidatorID) uint GetValStakedTokens(chain ChainID, validatorAddress string) uint GetQueryNodeIP(chain ChainID) string + GetInflationRate(chain ChainID) float64 } // TODO: replace ExecutionTarget with new TargetDriver interface @@ -153,7 +154,6 @@ type ProposalAndType struct { RawProposal json.RawMessage Type string } - type ChainState struct { ValBalances *map[ValidatorID]uint Proposals *map[uint]Proposal @@ -170,6 +170,7 @@ type ChainState struct { RegisteredConsumerRewardDenoms *[]string ClientsFrozenHeights *map[string]clienttypes.Height HasToValidate *map[ValidatorID][]ChainID // only relevant to provider chain + InflationRateChange *int // whether the inflation rate between two blocks changes negatively (any negative number), is equal (0), or changes positively (any positive number) } // custom marshal and unmarshal functions for the chainstate that convert proposals to/from the auxiliary type with type info diff --git a/tests/e2e/v4/state.go b/tests/e2e/v4/state.go index 70ca8afe7c..ab8fc58267 100644 --- a/tests/e2e/v4/state.go +++ b/tests/e2e/v4/state.go @@ -236,7 +236,7 @@ func (tr Commands) GetBalance(chain ChainID, validator ValidatorID) uint { // interchain-securityd query gov proposals func (tr Commands) GetProposal(chain ChainID, proposal uint) Proposal { - var noProposalRegex = regexp.MustCompile(`doesn't exist: key not found`) + noProposalRegex := regexp.MustCompile(`doesn't exist: key not found`) binaryName := tr.ChainConfigs[chain].BinaryName bz, err := tr.Target.ExecCommand(binaryName, @@ -411,6 +411,7 @@ func (tr Commands) GetConsumerChains(chain ChainID) map[ChainID]bool { return chains } + func (tr Commands) GetConsumerAddress(consumerChain ChainID, validator ValidatorID) string { binaryName := tr.ChainConfigs[ChainID("provi")].BinaryName cmd := tr.Target.ExecCommand(binaryName, @@ -656,3 +657,20 @@ func (tr Commands) GetHasToValidate(validator ValidatorID) []ChainID { func uintPtr(i uint) *uint { return &i } + +func (tr Commands) GetInflationRate( + chain ChainID, +) float64 { + binaryName := tr.ChainConfigs[chain].BinaryName + bz, err := tr.Target.ExecCommand(binaryName, + "query", "mint", "inflation", + `--node`, tr.GetQueryNode(chain), + `-o`, `json`, + ).CombinedOutput() + if err != nil { + log.Fatal(err, "\n", string(bz)) + } + + inflationRate := gjson.Get(string(bz), "inflation").Float() + return inflationRate +} diff --git a/testutil/keeper/unit_test_helpers.go b/testutil/keeper/unit_test_helpers.go index aeee5363d1..a2052c14b6 100644 --- a/testutil/keeper/unit_test_helpers.go +++ b/testutil/keeper/unit_test_helpers.go @@ -298,6 +298,7 @@ func GetTestConsumerAdditionProp() *providertypes.ConsumerAdditionProposal { nil, 0, 0, + false, ).(*providertypes.ConsumerAdditionProposal) return prop diff --git a/x/ccv/provider/client/legacy_proposal_handler.go b/x/ccv/provider/client/legacy_proposal_handler.go index a1e7a4acc8..78e144ae87 100644 --- a/x/ccv/provider/client/legacy_proposal_handler.go +++ b/x/ccv/provider/client/legacy_proposal_handler.go @@ -61,7 +61,10 @@ Where proposal.json contains: "validators_power_cap": 32, "validator_set_cap": 50, "allowlist": [], - "denylist": ["validatorAConsensusAddress", "validatorBConsensusAddress"] + "denylist": ["validatorAConsensusAddress", "validatorBConsensusAddress"], + "min_stake": 100000000000, + "max_validator_rank": 180, + "allow_inactive_vals": false } `, RunE: func(cmd *cobra.Command, args []string) error { @@ -85,7 +88,7 @@ Where proposal.json contains: proposal.DistributionTransmissionChannel, proposal.HistoricalEntries, proposal.CcvTimeoutPeriod, proposal.TransferTimeoutPeriod, proposal.UnbondingPeriod, proposal.TopN, proposal.ValidatorsPowerCap, proposal.ValidatorSetCap, proposal.Allowlist, proposal.Denylist, - proposal.MinStake, proposal.MaxValidatorRank) + proposal.MinStake, proposal.MaxValidatorRank, proposal.AllowInactiveVals) from := clientCtx.GetFromAddress() @@ -246,7 +249,10 @@ Where proposal.json contains: "validators_power_cap": 32, "validator_set_cap": 50, "allowlist": [], - "denylist": ["validatorAConsensusAddress", "validatorBConsensusAddress"] + "denylist": ["validatorAConsensusAddress", "validatorBConsensusAddress"], + "min_stake": 100000000000, + "max_validator_rank": 180, + "allow_inactive_vals": false } `, RunE: func(cmd *cobra.Command, args []string) error { @@ -262,7 +268,7 @@ Where proposal.json contains: content := types.NewConsumerModificationProposal( proposal.Title, proposal.Summary, proposal.ChainId, proposal.TopN, - proposal.ValidatorsPowerCap, proposal.ValidatorSetCap, proposal.Allowlist, proposal.Denylist, proposal.MinStake, proposal.MaxValidatorRank) + proposal.ValidatorsPowerCap, proposal.ValidatorSetCap, proposal.Allowlist, proposal.Denylist, proposal.MinStake, proposal.MaxValidatorRank, proposal.AllowInactiveVals) from := clientCtx.GetFromAddress() diff --git a/x/ccv/provider/client/legacy_proposals.go b/x/ccv/provider/client/legacy_proposals.go index cf90892e13..d6708dcdb2 100644 --- a/x/ccv/provider/client/legacy_proposals.go +++ b/x/ccv/provider/client/legacy_proposals.go @@ -43,6 +43,7 @@ type ConsumerAdditionProposalJSON struct { Denylist []string `json:"denylist"` MinStake uint64 `json:"min_stake"` MaxValidatorRank uint32 `json:"max_validator_rank"` + AllowInactiveVals bool `json:"allow_inactive_vals"` } type ConsumerAdditionProposalReq struct { @@ -176,6 +177,7 @@ type ConsumerModificationProposalJSON struct { Denylist []string `json:"denylist"` MinStake uint64 `json:"min_stake"` MaxValidatorRank uint32 `json:"max_validator_rank"` + AllowInactiveVals bool `json:"allow_inactive_vals"` Deposit string `json:"deposit"` } diff --git a/x/ccv/provider/keeper/grpc_query_test.go b/x/ccv/provider/keeper/grpc_query_test.go index 55bc0cca91..37cc335b03 100644 --- a/x/ccv/provider/keeper/grpc_query_test.go +++ b/x/ccv/provider/keeper/grpc_query_test.go @@ -213,6 +213,11 @@ func TestQueryConsumerChainsValidatorHasToValidate(t *testing.T) { // set `providerAddr` as an opted-in validator on "chain3" pk.SetOptedIn(ctx, "chain3", providerAddr) + // set max provider consensus vals to include all validators + params := pk.GetParams(ctx) + params.MaxProviderConsensusValidators = 180 + pk.SetParams(ctx, params) + // `providerAddr` has to validate "chain1" because it is a consumer validator in this chain, as well as "chain3" // because it opted in, in "chain3" and `providerAddr` belongs to the bonded validators expectedChains := []string{"chain1", "chain3"} diff --git a/x/ccv/provider/keeper/keeper.go b/x/ccv/provider/keeper/keeper.go index 7a7591e26b..97bd7888e7 100644 --- a/x/ccv/provider/keeper/keeper.go +++ b/x/ccv/provider/keeper/keeper.go @@ -1664,3 +1664,46 @@ func (k Keeper) DeleteMaxValidatorRank( store := ctx.KVStore(k.storeKey) store.Delete(types.MaxValidatorRankKey(chainID)) } + +// SetAllowInactiveValidators sets whether inactive validators are allowed to validate +// a given consumer chain. +func (k Keeper) SetAllowInactiveValidators( + ctx sdk.Context, + chainID string, + allowed bool, +) { + store := ctx.KVStore(k.storeKey) + + var buf []byte + if allowed { + buf = []byte{1} + } else { + buf = []byte{0} + } + + store.Set(types.AllowInactiveValidatorsKey(chainID), buf) +} + +// GetAllowInactiveValidators returns whether inactive validators are allowed to validate +// a given consumer chain. +func (k Keeper) GetAllowInactiveValidators( + ctx sdk.Context, + chainID string, +) (bool, bool) { + store := ctx.KVStore(k.storeKey) + buf := store.Get(types.AllowInactiveValidatorsKey(chainID)) + if buf == nil { + return false, false + } + return buf[0] == 1, true +} + +// DeleteAllowInactiveValidators removes the flag of whether inactive validators are allowed to validate +// a given consumer chain. +func (k Keeper) DeleteAllowInactiveValidators( + ctx sdk.Context, + chainID string, +) { + store := ctx.KVStore(k.storeKey) + store.Delete(types.AllowInactiveValidatorsKey(chainID)) +} diff --git a/x/ccv/provider/keeper/keeper_test.go b/x/ccv/provider/keeper/keeper_test.go index 5703bfe5f9..ec7f783e64 100644 --- a/x/ccv/provider/keeper/keeper_test.go +++ b/x/ccv/provider/keeper/keeper_test.go @@ -808,7 +808,8 @@ func TestDenylist(t *testing.T) { // - MaxValidatorRank // - ValidatorSetCap // - ValidatorPowersCap -func TestKeeperIntConsumerParams(t *testing.T) { +// - AllowInactiveValidators +func TestKeeperConsumerParams(t *testing.T) { k, ctx, _, _ := testkeeper.GetProviderKeeperAndCtx(t, testkeeper.NewInMemKeeperParams(t)) tests := []struct { @@ -865,28 +866,40 @@ func TestKeeperIntConsumerParams(t *testing.T) { initialValue: 10, updatedValue: 11, }, + { + name: "Allow Inactive Validators", + settingFunc: func(ctx sdk.Context, id string, val int64) { k.SetAllowInactiveValidators(ctx, id, val == 1) }, + getFunc: func(ctx sdk.Context, id string) (int64, bool) { + val, found := k.GetAllowInactiveValidators(ctx, id) + res := int64(0) // default value + if val { + res = 1 + } + return int64(res), found + }, + initialValue: 1, + updatedValue: 0, + }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { chainID := "chainID" - initialValue := 1000 - updatedValue := 2000 // Set initial value - tt.settingFunc(ctx, chainID, int64(initialValue)) + tt.settingFunc(ctx, chainID, int64(tt.initialValue)) // Retrieve and check initial value actualValue, found := tt.getFunc(ctx, chainID) require.True(t, found) - require.EqualValues(t, initialValue, actualValue) + require.EqualValues(t, tt.initialValue, actualValue) // Update value - tt.settingFunc(ctx, chainID, int64(updatedValue)) + tt.settingFunc(ctx, chainID, int64(tt.updatedValue)) // Retrieve and check updated value newActualValue, found := tt.getFunc(ctx, chainID) require.True(t, found) - require.EqualValues(t, updatedValue, newActualValue) + require.EqualValues(t, tt.updatedValue, newActualValue) // Check non-existent chain ID _, found = tt.getFunc(ctx, "not the chainID") diff --git a/x/ccv/provider/keeper/legacy_proposal.go b/x/ccv/provider/keeper/legacy_proposal.go index 83fe0e3204..7b85f572ce 100644 --- a/x/ccv/provider/keeper/legacy_proposal.go +++ b/x/ccv/provider/keeper/legacy_proposal.go @@ -94,6 +94,7 @@ func (k Keeper) HandleLegacyConsumerModificationProposal(ctx sdk.Context, p *typ k.SetValidatorSetCap(ctx, p.ChainId, p.ValidatorSetCap) k.SetMinStake(ctx, p.ChainId, p.MinStake) k.SetMaxValidatorRank(ctx, p.ChainId, p.MaxRank) + k.SetAllowInactiveValidators(ctx, p.ChainId, p.AllowInactiveVals) k.DeleteAllowlist(ctx, p.ChainId) for _, address := range p.Allowlist { diff --git a/x/ccv/provider/keeper/legacy_proposal_test.go b/x/ccv/provider/keeper/legacy_proposal_test.go index b8191d4217..0684f4ca63 100644 --- a/x/ccv/provider/keeper/legacy_proposal_test.go +++ b/x/ccv/provider/keeper/legacy_proposal_test.go @@ -64,6 +64,7 @@ func TestHandleLegacyConsumerAdditionProposal(t *testing.T) { nil, 0, 0, + false, ).(*providertypes.ConsumerAdditionProposal), blockTime: now, expAppendProp: true, @@ -96,6 +97,7 @@ func TestHandleLegacyConsumerAdditionProposal(t *testing.T) { nil, 0, 0, + false, ).(*providertypes.ConsumerAdditionProposal), blockTime: now, expAppendProp: false, @@ -288,6 +290,7 @@ func TestHandleConsumerModificationProposal(t *testing.T) { providerKeeper.SetDenylist(ctx, chainID, providertypes.NewProviderConsAddress([]byte("denylistedAddr1"))) providerKeeper.SetMinStake(ctx, chainID, 1000) providerKeeper.SetMaxValidatorRank(ctx, chainID, 180) + providerKeeper.SetAllowInactiveValidators(ctx, chainID, true) expectedTopN := uint32(75) expectedValidatorsPowerCap := uint32(67) @@ -296,6 +299,7 @@ func TestHandleConsumerModificationProposal(t *testing.T) { expectedDenylistedValidator := "cosmosvalcons1nx7n5uh0ztxsynn4sje6eyq2ud6rc6klc96w39" expectedMinStake := uint64(0) expectedMaxValidatorRank := uint32(20) + expectedAllowInactiveValidators := false proposal := providertypes.NewConsumerModificationProposal("title", "description", chainID, expectedTopN, expectedValidatorsPowerCap, @@ -304,6 +308,7 @@ func TestHandleConsumerModificationProposal(t *testing.T) { []string{expectedDenylistedValidator}, expectedMinStake, expectedMaxValidatorRank, + expectedAllowInactiveValidators, ).(*providertypes.ConsumerModificationProposal) err := providerKeeper.HandleLegacyConsumerModificationProposal(ctx, proposal) @@ -331,4 +336,7 @@ func TestHandleConsumerModificationProposal(t *testing.T) { actualMaxValidatorRank, _ := providerKeeper.GetMaxValidatorRank(ctx, chainID) require.Equal(t, expectedMaxValidatorRank, actualMaxValidatorRank) + + actualAllowInactiveValidators, _ := providerKeeper.GetAllowInactiveValidators(ctx, chainID) + require.Equal(t, expectedAllowInactiveValidators, actualAllowInactiveValidators) } diff --git a/x/ccv/provider/keeper/partial_set_security.go b/x/ccv/provider/keeper/partial_set_security.go index fbd55e53da..dd62613cb3 100644 --- a/x/ccv/provider/keeper/partial_set_security.go +++ b/x/ccv/provider/keeper/partial_set_security.go @@ -332,6 +332,17 @@ func (k Keeper) ComputeNextValidators(ctx sdk.Context, chainID string, bondedVal return bondedValidators[i].GetTokens().GT(bondedValidators[j].GetTokens()) }) + // if inactive validators are not allowed, only consider the first `MaxProviderConsensusValidators` validators + // since those are the ones that participate in consensus + allowInactiveVals, found := k.GetAllowInactiveValidators(ctx, chainID) + if !allowInactiveVals || !found { + // only leave the first MaxProviderConsensusValidators bonded validators + maxProviderConsensusVals := k.GetMaxProviderConsensusValidators(ctx) + if len(bondedValidators) > int(maxProviderConsensusVals) { + bondedValidators = bondedValidators[:maxProviderConsensusVals] + } + } + // take only the first `MaxValidatorRank` many validators; others are not allowed to validate maxRank, found := k.GetMaxValidatorRank(ctx, chainID) if found && maxRank > 0 && int(maxRank) < len(bondedValidators) { diff --git a/x/ccv/provider/keeper/partial_set_security_test.go b/x/ccv/provider/keeper/partial_set_security_test.go index b7127a462a..e015af850d 100644 --- a/x/ccv/provider/keeper/partial_set_security_test.go +++ b/x/ccv/provider/keeper/partial_set_security_test.go @@ -804,6 +804,12 @@ func TestMaxValidatorRank(t *testing.T) { for _, tc := range testCases { t.Run(tc.name, func(t *testing.T) { providerKeeper.SetMaxValidatorRank(ctx, "chainID", tc.maxRank) + + // set max provider consensus vals to include all validators + params := providerKeeper.GetParams(ctx) + params.MaxProviderConsensusValidators = 180 + providerKeeper.SetParams(ctx, params) + nextVals := providerKeeper.ComputeNextValidators(ctx, "chainID", vals) nextConsAddrs := make([]types.ProviderConsAddress, len(nextVals)) for i, val := range nextVals { @@ -814,3 +820,57 @@ func TestMaxValidatorRank(t *testing.T) { }) } } + +// TestMaxProviderConsensusValidators checks that the number of validators in the next validator set is at most +// the maxProviderConsensusValidators parameter if the consumer chain does not allow inactive validators to validate. +func TestIfInactiveValsDisallowedProperty(t *testing.T) { + rapid.Check(t, func(r *rapid.T) { + providerKeeper, ctx, ctrl, mocks := testkeeper.GetProviderKeeperAndCtx(t, testkeeper.NewInMemKeeperParams(t)) + defer ctrl.Finish() + + // Generate a random number of validators with random powers + valPowers := rapid.SliceOfN(rapid.Int64Range(1, 100), 1, 100).Draw(r, "valPowers") + vals, consAddrs := createStakingValidatorsAndMocks(ctx, mocks, valPowers...) + + // opt the validators in + for _, valAddr := range consAddrs { + providerKeeper.SetOptedIn(ctx, "chainID", valAddr) + } + + // Randomly choose values for parameters + minStake := rapid.Uint64Range(0, 101).Draw(r, "minStake") + maxRank := rapid.Uint32Range(0, 11).Draw(r, "maxRank") + maxProviderConsensusVals := rapid.Uint32Range(1, 11).Draw(r, "maxProviderConsensusVals") + + // Set up the parameters in the provider keeper + providerKeeper.SetAllowInactiveValidators(ctx, "chainID", false) // do not allow inactive validators + providerKeeper.SetMinStake(ctx, "chainID", minStake) + providerKeeper.SetMaxValidatorRank(ctx, "chainID", maxRank) + params := providerKeeper.GetParams(ctx) + params.MaxProviderConsensusValidators = int64(maxProviderConsensusVals) + providerKeeper.SetParams(ctx, params) + + // Compute the next validators + nextVals := providerKeeper.ComputeNextValidators(ctx, "chainID", vals) + + // Check that the length of nextVals is at most maxProviderConsensusVals + require.LessOrEqual(t, len(nextVals), int(maxProviderConsensusVals), "The length of nextVals should be at most maxProviderConsensusVals") + + // Sanity check: we only get 0 next validators if either: + // - maxProviderConsensusVals is 0 + // - the maximal validator power is less than the min stake + if len(nextVals) == 0 { + maxValPower := int64(0) + for _, power := range valPowers { + if power > maxValPower { + maxValPower = power + } + } + require.True( + t, + maxProviderConsensusVals == 0 || maxValPower < int64(minStake), + "The length of nextVals should only be 0 if either maxProviderConsensusVals is 0 or the maximal validator power is less than the min stake", + ) + } + }) +} diff --git a/x/ccv/provider/keeper/proposal.go b/x/ccv/provider/keeper/proposal.go index af48ea3597..e1da24de18 100644 --- a/x/ccv/provider/keeper/proposal.go +++ b/x/ccv/provider/keeper/proposal.go @@ -80,6 +80,7 @@ func (k Keeper) HandleConsumerModificationProposal(ctx sdk.Context, proposal *ty Denylist: proposal.Denylist, MinStake: proposal.MinStake, MaxRank: proposal.MaxRank, + AllowInactiveVals: proposal.AllowInactiveVals, } return k.HandleLegacyConsumerModificationProposal(ctx, &p) @@ -240,6 +241,9 @@ func (k Keeper) StopConsumerChain(ctx sdk.Context, chainID string, closeChan boo k.DeleteValidatorSetCap(ctx, chainID) k.DeleteAllowlist(ctx, chainID) k.DeleteDenylist(ctx, chainID) + k.DeleteMaxValidatorRank(ctx, chainID) + k.DeleteAllowInactiveValidators(ctx, chainID) + k.DeleteMinStake(ctx, chainID) k.DeleteAllOptedIn(ctx, chainID) k.DeleteConsumerValSet(ctx, chainID) @@ -394,6 +398,7 @@ func (k Keeper) BeginBlockInit(ctx sdk.Context) { k.SetValidatorsPowerCap(cachedCtx, prop.ChainId, prop.ValidatorsPowerCap) k.SetMinStake(cachedCtx, prop.ChainId, prop.MinStake) k.SetMaxValidatorRank(cachedCtx, prop.ChainId, prop.MaxRank) + k.SetAllowInactiveValidators(cachedCtx, prop.ChainId, prop.AllowInactiveVals) for _, address := range prop.Allowlist { consAddr, err := sdk.ConsAddressFromBech32(address) diff --git a/x/ccv/provider/keeper/proposal_test.go b/x/ccv/provider/keeper/proposal_test.go index 225d73282c..a06a40e809 100644 --- a/x/ccv/provider/keeper/proposal_test.go +++ b/x/ccv/provider/keeper/proposal_test.go @@ -75,6 +75,7 @@ func TestHandleConsumerAdditionProposal(t *testing.T) { nil, 0, 0, + false, ).(*providertypes.ConsumerAdditionProposal), blockTime: now, expAppendProp: true, @@ -107,6 +108,7 @@ func TestHandleConsumerAdditionProposal(t *testing.T) { nil, 0, 0, + false, ).(*providertypes.ConsumerAdditionProposal), blockTime: now, expAppendProp: false, @@ -815,6 +817,7 @@ func TestBeginBlockInit(t *testing.T) { nil, 0, 0, + false, ).(*providertypes.ConsumerAdditionProposal), providertypes.NewConsumerAdditionProposal( "title", "spawn time passed", "chain2", clienttypes.NewHeight(3, 4), []byte{}, []byte{}, @@ -833,6 +836,7 @@ func TestBeginBlockInit(t *testing.T) { nil, 0, 0, + false, ).(*providertypes.ConsumerAdditionProposal), providertypes.NewConsumerAdditionProposal( "title", "spawn time not passed", "chain3", clienttypes.NewHeight(3, 4), []byte{}, []byte{}, @@ -851,6 +855,7 @@ func TestBeginBlockInit(t *testing.T) { nil, 0, 0, + false, ).(*providertypes.ConsumerAdditionProposal), providertypes.NewConsumerAdditionProposal( "title", "invalid proposal: chain id already exists", "chain2", clienttypes.NewHeight(4, 5), []byte{}, []byte{}, @@ -869,6 +874,7 @@ func TestBeginBlockInit(t *testing.T) { nil, 0, 0, + false, ).(*providertypes.ConsumerAdditionProposal), providertypes.NewConsumerAdditionProposal( "title", "opt-in chain with at least one validator opted in", "chain5", clienttypes.NewHeight(3, 4), []byte{}, []byte{}, @@ -887,6 +893,7 @@ func TestBeginBlockInit(t *testing.T) { nil, 0, 0, + false, ).(*providertypes.ConsumerAdditionProposal), providertypes.NewConsumerAdditionProposal( "title", "opt-in chain with no validator opted in", "chain6", clienttypes.NewHeight(3, 4), []byte{}, []byte{}, @@ -905,6 +912,7 @@ func TestBeginBlockInit(t *testing.T) { nil, 0, 0, + false, ).(*providertypes.ConsumerAdditionProposal), } diff --git a/x/ccv/provider/keeper/relay_test.go b/x/ccv/provider/keeper/relay_test.go index d901faee4f..1cb48df6ad 100644 --- a/x/ccv/provider/keeper/relay_test.go +++ b/x/ccv/provider/keeper/relay_test.go @@ -852,7 +852,7 @@ func TestQueueVSCPacketsWithPowerCapping(t *testing.T) { // set a power-capping of 40% providerKeeper.SetValidatorsPowerCap(ctx, "chainID", 40) - // set max provider consensus validators to a value that is larger than the number of validators + // set max provider consensus vals to include all validators params := providerKeeper.GetParams(ctx) params.MaxProviderConsensusValidators = 180 providerKeeper.SetParams(ctx, params) diff --git a/x/ccv/provider/migrations/vX/migrations.go b/x/ccv/provider/migrations/vX/migrations.go index 9040c82ee2..b2b89f0fad 100644 --- a/x/ccv/provider/migrations/vX/migrations.go +++ b/x/ccv/provider/migrations/vX/migrations.go @@ -14,3 +14,11 @@ func InitializeMaxValidatorsForExistingConsumers(ctx sdk.Context, providerKeeper providerKeeper.SetValidatorSetCap(ctx, chainID, uint32(maxVals)) } } + +// InitializeAllowInactiveVals initializes the allow inactive validators parameter to be false +// for all existing consumer chains. +func InitializeAllowInactiveVals(ctx sdk.Context, providerKeeper providerkeeper.Keeper) { + for _, chainID := range providerKeeper.GetAllRegisteredConsumerChainIDs(ctx) { + providerKeeper.SetAllowInactiveValidators(ctx, chainID, false) + } +} diff --git a/x/ccv/provider/proposal_handler_test.go b/x/ccv/provider/proposal_handler_test.go index 5fbfdb0c91..89475fa4e0 100644 --- a/x/ccv/provider/proposal_handler_test.go +++ b/x/ccv/provider/proposal_handler_test.go @@ -53,6 +53,7 @@ func TestProviderProposalHandler(t *testing.T) { nil, 0, 0, + false, ), blockTime: hourFromNow, // ctx blocktime is after proposal's spawn time expValidConsumerAddition: true, diff --git a/x/ccv/provider/types/keys.go b/x/ccv/provider/types/keys.go index cd810fa44c..0adff80bd4 100644 --- a/x/ccv/provider/types/keys.go +++ b/x/ccv/provider/types/keys.go @@ -198,6 +198,10 @@ const ( // a validator can have to be a validator on the consumer chain MaxValidatorRankPrefix + // AllowInactiveValidatorsPrefix is the byte prefix for storing the mapping from consumer chains to the boolean value + // that determines whether inactive validators can validate on that chain + AllowInactiveValidatorsPrefix + // NOTE: DO NOT ADD NEW BYTE PREFIXES HERE WITHOUT ADDING THEM TO getAllKeyPrefixes() IN keys_test.go ) @@ -649,6 +653,10 @@ func MaxValidatorRankKey(chainID string) []byte { return ChainIdWithLenKey(MaxValidatorRankPrefix, chainID) } +func AllowInactiveValidatorsKey(chainID string) []byte { + return ChainIdWithLenKey(AllowInactiveValidatorsPrefix, chainID) +} + // // End of generic helpers section // diff --git a/x/ccv/provider/types/keys_test.go b/x/ccv/provider/types/keys_test.go index 4bdc860310..e4f9b52221 100644 --- a/x/ccv/provider/types/keys_test.go +++ b/x/ccv/provider/types/keys_test.go @@ -66,6 +66,7 @@ func getAllKeyPrefixes() []byte { providertypes.ParametersByteKey, providertypes.MinStakePrefix, providertypes.MaxValidatorRankPrefix, + providertypes.AllowInactiveValidatorsPrefix, } } @@ -112,6 +113,7 @@ func getAllFullyDefinedKeys() [][]byte { providertypes.EquivocationEvidenceMinHeightKey("chainID"), providertypes.MinStakeKey("chainID"), providertypes.MaxValidatorRankKey("chainID"), + providertypes.AllowInactiveValidatorsKey("chainID"), } } diff --git a/x/ccv/provider/types/legacy_proposal.go b/x/ccv/provider/types/legacy_proposal.go index a6ca7c1b4f..44da78161d 100644 --- a/x/ccv/provider/types/legacy_proposal.go +++ b/x/ccv/provider/types/legacy_proposal.go @@ -60,6 +60,7 @@ func NewConsumerAdditionProposal(title, description, chainID string, denylist []string, minStake uint64, maxValidatorRank uint32, + allowInactiveVals bool, ) govv1beta1.Content { return &ConsumerAdditionProposal{ Title: title, @@ -83,6 +84,7 @@ func NewConsumerAdditionProposal(title, description, chainID string, Denylist: denylist, MinStake: minStake, MaxRank: maxValidatorRank, + AllowInactiveVals: allowInactiveVals, } } @@ -249,6 +251,7 @@ func NewConsumerModificationProposal(title, description, chainID string, denylist []string, minStake uint64, maxValidatorRank uint32, + allowInactiveVals bool, ) govv1beta1.Content { return &ConsumerModificationProposal{ Title: title, @@ -261,6 +264,7 @@ func NewConsumerModificationProposal(title, description, chainID string, Denylist: denylist, MinStake: minStake, MaxRank: maxValidatorRank, + AllowInactiveVals: allowInactiveVals, } } diff --git a/x/ccv/provider/types/legacy_proposal_test.go b/x/ccv/provider/types/legacy_proposal_test.go index 5db9af0c0c..8dd392f86b 100644 --- a/x/ccv/provider/types/legacy_proposal_test.go +++ b/x/ccv/provider/types/legacy_proposal_test.go @@ -43,6 +43,7 @@ func TestConsumerAdditionProposalValidateBasic(t *testing.T) { nil, 0, 0, + false, ), true, }, @@ -63,6 +64,7 @@ func TestConsumerAdditionProposalValidateBasic(t *testing.T) { nil, 0, 0, + false, ), true, }, @@ -83,6 +85,7 @@ func TestConsumerAdditionProposalValidateBasic(t *testing.T) { nil, 0, 0, + false, ), false, }, @@ -103,6 +106,7 @@ func TestConsumerAdditionProposalValidateBasic(t *testing.T) { nil, 0, 0, + false, ), false, }, @@ -143,6 +147,7 @@ func TestConsumerAdditionProposalValidateBasic(t *testing.T) { nil, 0, 0, + false, ), false, }, @@ -163,6 +168,7 @@ func TestConsumerAdditionProposalValidateBasic(t *testing.T) { nil, 0, 0, + false, ), false, }, @@ -183,6 +189,7 @@ func TestConsumerAdditionProposalValidateBasic(t *testing.T) { nil, 0, 0, + false, ), false, }, @@ -203,6 +210,7 @@ func TestConsumerAdditionProposalValidateBasic(t *testing.T) { nil, 0, 0, + false, ), false, }, @@ -223,6 +231,7 @@ func TestConsumerAdditionProposalValidateBasic(t *testing.T) { nil, 0, 0, + false, ), false, }, @@ -243,6 +252,7 @@ func TestConsumerAdditionProposalValidateBasic(t *testing.T) { nil, 0, 0, + false, ), false, }, @@ -263,6 +273,7 @@ func TestConsumerAdditionProposalValidateBasic(t *testing.T) { nil, 0, 0, + false, ), false, }, @@ -283,6 +294,7 @@ func TestConsumerAdditionProposalValidateBasic(t *testing.T) { nil, 0, 0, + false, ), false, }, @@ -303,6 +315,7 @@ func TestConsumerAdditionProposalValidateBasic(t *testing.T) { nil, 0, 0, + false, ), false, }, @@ -323,6 +336,7 @@ func TestConsumerAdditionProposalValidateBasic(t *testing.T) { nil, 0, 0, + false, ), false, }, @@ -343,6 +357,7 @@ func TestConsumerAdditionProposalValidateBasic(t *testing.T) { nil, 0, 0, + false, ), false, }, @@ -363,6 +378,7 @@ func TestConsumerAdditionProposalValidateBasic(t *testing.T) { nil, 0, 0, + false, ), false, }, @@ -383,6 +399,7 @@ func TestConsumerAdditionProposalValidateBasic(t *testing.T) { []string{"addr2", "addr3"}, 0, 0, + false, ), true, }, @@ -415,6 +432,7 @@ func TestMarshalConsumerAdditionProposal(t *testing.T) { nil, 0, 0, + false, ) cccp, ok := content.(*types.ConsumerAdditionProposal) @@ -465,6 +483,7 @@ func TestConsumerAdditionProposalString(t *testing.T) { []string{}, 0, 0, + false, ) expect := fmt.Sprintf(`CreateConsumerChain Proposal @@ -558,6 +577,7 @@ func TestConsumerModificationProposalValidateBasic(t *testing.T) { nil, 0, 0, + false, ), true, }, @@ -571,6 +591,7 @@ func TestConsumerModificationProposalValidateBasic(t *testing.T) { nil, 0, 0, + false, ), false, }, @@ -584,6 +605,7 @@ func TestConsumerModificationProposalValidateBasic(t *testing.T) { nil, 0, 0, + false, ), false, }, @@ -597,6 +619,7 @@ func TestConsumerModificationProposalValidateBasic(t *testing.T) { nil, 0, 0, + false, ), false, }, @@ -610,6 +633,7 @@ func TestConsumerModificationProposalValidateBasic(t *testing.T) { []string{"addr2", "addr3"}, 0, 0, + false, ), true, }, diff --git a/x/ccv/provider/types/provider.pb.go b/x/ccv/provider/types/provider.pb.go index 227a4bacdf..a8bacf0f3f 100644 --- a/x/ccv/provider/types/provider.pb.go +++ b/x/ccv/provider/types/provider.pb.go @@ -117,6 +117,8 @@ type ConsumerAdditionProposal struct { MinStake uint64 `protobuf:"varint,20,opt,name=min_stake,json=minStake,proto3" json:"min_stake,omitempty"` // Corresponds to the maximal rank in the provider chain validator set that a validator can have to validate on the consumer chain. MaxRank uint32 `protobuf:"varint,21,opt,name=max_rank,json=maxRank,proto3" json:"max_rank,omitempty"` + // Corresponds to whether inactive validators are allowed to validate the consumer chain. + AllowInactiveVals bool `protobuf:"varint,22,opt,name=allow_inactive_vals,json=allowInactiveVals,proto3" json:"allow_inactive_vals,omitempty"` } func (m *ConsumerAdditionProposal) Reset() { *m = ConsumerAdditionProposal{} } @@ -261,6 +263,8 @@ type ConsumerModificationProposal struct { MinStake uint64 `protobuf:"varint,9,opt,name=min_stake,json=minStake,proto3" json:"min_stake,omitempty"` // Corresponds to the maximal rank in the provider chain validator set that a validator can have to validate on the consumer chain. MaxRank uint32 `protobuf:"varint,10,opt,name=max_rank,json=maxRank,proto3" json:"max_rank,omitempty"` + // Corresponds to whether inactive validators are allowed to validate the consumer chain. + AllowInactiveVals bool `protobuf:"varint,11,opt,name=allow_inactive_vals,json=allowInactiveVals,proto3" json:"allow_inactive_vals,omitempty"` } func (m *ConsumerModificationProposal) Reset() { *m = ConsumerModificationProposal{} } @@ -366,6 +370,13 @@ func (m *ConsumerModificationProposal) GetMaxRank() uint32 { return 0 } +func (m *ConsumerModificationProposal) GetAllowInactiveVals() bool { + if m != nil { + return m.AllowInactiveVals + } + return false +} + // EquivocationProposal is a governance proposal on the provider chain to // punish a validator for equivocation on a consumer chain. // @@ -1718,136 +1729,138 @@ func init() { } var fileDescriptor_f22ec409a72b7b72 = []byte{ - // 2066 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x58, 0xcd, 0x6f, 0x1b, 0xc7, - 0x15, 0xd7, 0x8a, 0x94, 0x44, 0x0e, 0xf5, 0x39, 0x92, 0xe3, 0x95, 0xa2, 0x52, 0xf4, 0xa6, 0x71, - 0xd5, 0xb8, 0x26, 0x23, 0x07, 0x01, 0x0c, 0xb7, 0x41, 0x20, 0x51, 0x4e, 0x2c, 0xbb, 0xb6, 0x95, - 0x95, 0x2a, 0xa3, 0xed, 0x61, 0x31, 0x9c, 0x1d, 0x93, 0x03, 0xee, 0xee, 0xac, 0x67, 0x86, 0x6b, - 0xf3, 0xd2, 0x73, 0x2f, 0x05, 0xd2, 0x43, 0x81, 0xa0, 0x97, 0xa6, 0x3d, 0x15, 0x3d, 0x14, 0x3d, - 0xf4, 0x2f, 0xe8, 0x29, 0xe8, 0xa5, 0x39, 0x15, 0x3d, 0x25, 0x85, 0x7c, 0xe8, 0xa1, 0xff, 0x44, - 0x31, 0xb3, 0x9f, 0xa4, 0x3e, 0x4c, 0x23, 0xcd, 0x45, 0xda, 0x7d, 0xf3, 0xde, 0xef, 0xbd, 0x79, - 0xdf, 0x4b, 0x70, 0x8b, 0x06, 0x92, 0x70, 0xdc, 0x43, 0x34, 0x70, 0x04, 0xc1, 0x03, 0x4e, 0xe5, - 0xb0, 0x85, 0x71, 0xd4, 0x0a, 0x39, 0x8b, 0xa8, 0x4b, 0x78, 0x2b, 0xda, 0xc9, 0x9e, 0x9b, 0x21, - 0x67, 0x92, 0xc1, 0xb7, 0xce, 0x91, 0x69, 0x62, 0x1c, 0x35, 0x33, 0xbe, 0x68, 0x67, 0xe3, 0xed, - 0x8b, 0x80, 0xa3, 0x9d, 0xd6, 0x73, 0xca, 0x49, 0x8c, 0xb5, 0xb1, 0xd6, 0x65, 0x5d, 0xa6, 0x1f, - 0x5b, 0xea, 0x29, 0xa1, 0x6e, 0x75, 0x19, 0xeb, 0x7a, 0xa4, 0xa5, 0xdf, 0x3a, 0x83, 0xa7, 0x2d, - 0x49, 0x7d, 0x22, 0x24, 0xf2, 0xc3, 0x84, 0xa1, 0x3e, 0xce, 0xe0, 0x0e, 0x38, 0x92, 0x94, 0x05, - 0x29, 0x00, 0xed, 0xe0, 0x16, 0x66, 0x9c, 0xb4, 0xb0, 0x47, 0x49, 0x20, 0x95, 0xd6, 0xf8, 0x29, - 0x61, 0x68, 0x29, 0x06, 0x8f, 0x76, 0x7b, 0x32, 0x26, 0x8b, 0x96, 0x24, 0x81, 0x4b, 0xb8, 0x4f, - 0x63, 0xe6, 0xfc, 0x2d, 0x11, 0xd8, 0x2c, 0x9c, 0x63, 0x3e, 0x0c, 0x25, 0x6b, 0xf5, 0xc9, 0x50, - 0x24, 0xa7, 0xd7, 0x31, 0x13, 0x3e, 0x13, 0x2d, 0xa2, 0xee, 0x1f, 0x60, 0xd2, 0x8a, 0x76, 0x3a, - 0x44, 0xa2, 0x9d, 0x8c, 0x90, 0xda, 0x9d, 0xf0, 0x75, 0x90, 0xc8, 0x79, 0x30, 0xa3, 0xa9, 0xdd, - 0xeb, 0xf1, 0xb9, 0x13, 0x7b, 0x24, 0x7e, 0x49, 0x8e, 0x56, 0x90, 0x4f, 0x03, 0xd6, 0xd2, 0x7f, - 0x63, 0x92, 0x75, 0x5a, 0x01, 0x66, 0x9b, 0x05, 0x62, 0xe0, 0x13, 0xbe, 0xeb, 0xba, 0x54, 0x39, - 0xe0, 0x90, 0xb3, 0x90, 0x09, 0xe4, 0xc1, 0x35, 0x30, 0x23, 0xa9, 0xf4, 0x88, 0x69, 0x34, 0x8c, - 0xed, 0xaa, 0x1d, 0xbf, 0xc0, 0x06, 0xa8, 0xb9, 0x44, 0x60, 0x4e, 0x43, 0xc5, 0x6c, 0x4e, 0xeb, - 0xb3, 0x22, 0x09, 0xae, 0x83, 0x4a, 0x1c, 0x35, 0xea, 0x9a, 0x25, 0x7d, 0x3c, 0xa7, 0xdf, 0x0f, - 0x5c, 0xf8, 0x31, 0x58, 0xa4, 0x01, 0x95, 0x14, 0x79, 0x4e, 0x8f, 0x28, 0xdf, 0x99, 0xe5, 0x86, - 0xb1, 0x5d, 0xbb, 0xb5, 0xd1, 0xa4, 0x1d, 0xdc, 0x54, 0xee, 0x6e, 0x26, 0x4e, 0x8e, 0x76, 0x9a, - 0xf7, 0x34, 0xc7, 0x5e, 0xf9, 0x8b, 0xaf, 0xb6, 0xa6, 0xec, 0x85, 0x44, 0x2e, 0x26, 0xc2, 0x6b, - 0x60, 0xbe, 0x4b, 0x02, 0x22, 0xa8, 0x70, 0x7a, 0x48, 0xf4, 0xcc, 0x99, 0x86, 0xb1, 0x3d, 0x6f, - 0xd7, 0x12, 0xda, 0x3d, 0x24, 0x7a, 0x70, 0x0b, 0xd4, 0x3a, 0x34, 0x40, 0x7c, 0x18, 0x73, 0xcc, - 0x6a, 0x0e, 0x10, 0x93, 0x34, 0x43, 0x1b, 0x00, 0x11, 0xa2, 0xe7, 0x81, 0xa3, 0x72, 0xc3, 0x9c, - 0x4b, 0x0c, 0x89, 0xf3, 0xa2, 0x99, 0xe6, 0x45, 0xf3, 0x38, 0x4d, 0x9c, 0xbd, 0x8a, 0x32, 0xe4, - 0xd3, 0xaf, 0xb7, 0x0c, 0xbb, 0xaa, 0xe5, 0xd4, 0x09, 0x7c, 0x04, 0x96, 0x07, 0x41, 0x87, 0x05, - 0x2e, 0x0d, 0xba, 0x4e, 0x48, 0x38, 0x65, 0xae, 0x59, 0xd1, 0x50, 0xeb, 0x67, 0xa0, 0xf6, 0x93, - 0x14, 0x8b, 0x91, 0x3e, 0x53, 0x48, 0x4b, 0x99, 0xf0, 0xa1, 0x96, 0x85, 0x9f, 0x00, 0x88, 0x71, - 0xa4, 0x4d, 0x62, 0x03, 0x99, 0x22, 0x56, 0x27, 0x47, 0x5c, 0xc6, 0x38, 0x3a, 0x8e, 0xa5, 0x13, - 0xc8, 0x9f, 0x83, 0xab, 0x92, 0xa3, 0x40, 0x3c, 0x25, 0x7c, 0x1c, 0x17, 0x4c, 0x8e, 0x7b, 0x25, - 0xc5, 0x18, 0x05, 0xbf, 0x07, 0x1a, 0x38, 0x49, 0x20, 0x87, 0x13, 0x97, 0x0a, 0xc9, 0x69, 0x67, - 0xa0, 0x64, 0x9d, 0xa7, 0x1c, 0x61, 0x9d, 0x23, 0x35, 0x9d, 0x04, 0xf5, 0x94, 0xcf, 0x1e, 0x61, - 0xfb, 0x28, 0xe1, 0x82, 0x8f, 0xc1, 0x77, 0x3b, 0x1e, 0xc3, 0x7d, 0xa1, 0x8c, 0x73, 0x46, 0x90, - 0xb4, 0x6a, 0x9f, 0x0a, 0xa1, 0xd0, 0xe6, 0x1b, 0xc6, 0x76, 0xc9, 0xbe, 0x16, 0xf3, 0x1e, 0x12, - 0xbe, 0x5f, 0xe0, 0x3c, 0x2e, 0x30, 0xc2, 0x9b, 0x00, 0xf6, 0xa8, 0x90, 0x8c, 0x53, 0x8c, 0x3c, - 0x87, 0x04, 0x92, 0x53, 0x22, 0xcc, 0x05, 0x2d, 0xbe, 0x92, 0x9f, 0xdc, 0x8d, 0x0f, 0xe0, 0x7d, - 0x70, 0xed, 0x42, 0xa5, 0x0e, 0xee, 0xa1, 0x20, 0x20, 0x9e, 0xb9, 0xa8, 0xaf, 0xb2, 0xe5, 0x5e, - 0xa0, 0xb3, 0x1d, 0xb3, 0xc1, 0x55, 0x30, 0x23, 0x59, 0xe8, 0x3c, 0x32, 0x97, 0x1a, 0xc6, 0xf6, - 0x82, 0x5d, 0x96, 0x2c, 0x7c, 0x04, 0xdf, 0x05, 0x6b, 0x11, 0xf2, 0xa8, 0x8b, 0x24, 0xe3, 0xc2, - 0x09, 0xd9, 0x73, 0xc2, 0x1d, 0x8c, 0x42, 0x73, 0x59, 0xf3, 0xc0, 0xfc, 0xec, 0x50, 0x1d, 0xb5, - 0x51, 0x08, 0xdf, 0x01, 0x2b, 0x19, 0xd5, 0x11, 0x44, 0x6a, 0xf6, 0x15, 0xcd, 0xbe, 0x94, 0x1d, - 0x1c, 0x11, 0xa9, 0x78, 0x37, 0x41, 0x15, 0x79, 0x1e, 0x7b, 0xee, 0x51, 0x21, 0x4d, 0xd8, 0x28, - 0x6d, 0x57, 0xed, 0x9c, 0x00, 0x37, 0x40, 0xc5, 0x25, 0xc1, 0x50, 0x1f, 0xae, 0xea, 0xc3, 0xec, - 0x1d, 0xbe, 0x09, 0xaa, 0xbe, 0xea, 0xb1, 0x12, 0xf5, 0x89, 0xb9, 0xd6, 0x30, 0xb6, 0xcb, 0x76, - 0xc5, 0xa7, 0xc1, 0x91, 0x7a, 0x57, 0xc5, 0xec, 0xa3, 0x17, 0x0e, 0x47, 0x41, 0xdf, 0xbc, 0xa2, - 0x35, 0xcf, 0xf9, 0xe8, 0x85, 0x8d, 0x82, 0xfe, 0x9d, 0xeb, 0xbf, 0xfc, 0x7c, 0x6b, 0xea, 0xb3, - 0xcf, 0xb7, 0xa6, 0xfe, 0xfe, 0xd7, 0x9b, 0x1b, 0x49, 0xa7, 0xe9, 0xb2, 0xa8, 0x99, 0x74, 0xa5, - 0x66, 0x9b, 0x05, 0x92, 0x04, 0xd2, 0xfa, 0x87, 0x01, 0xae, 0xb6, 0xb3, 0xd8, 0xfb, 0x2c, 0x42, - 0xde, 0xb7, 0xd9, 0x63, 0x76, 0x41, 0x55, 0x28, 0xe7, 0xeb, 0xaa, 0x2e, 0xbf, 0x46, 0x55, 0x57, - 0x94, 0x98, 0x3a, 0xb8, 0x53, 0x7f, 0xc5, 0x8d, 0xfe, 0x39, 0x0d, 0x36, 0xd3, 0x1b, 0x3d, 0x64, - 0x2e, 0x7d, 0x4a, 0x31, 0xfa, 0xb6, 0x5b, 0x67, 0x96, 0x52, 0xe5, 0x09, 0x52, 0x6a, 0xe6, 0xf5, - 0x52, 0x6a, 0x76, 0x82, 0x94, 0x9a, 0xbb, 0x2c, 0xa5, 0x2a, 0x97, 0xa5, 0x54, 0xf5, 0x92, 0x94, - 0x02, 0x23, 0x29, 0x65, 0xfd, 0xce, 0x00, 0x6b, 0x77, 0x9f, 0x0d, 0x68, 0xc4, 0xfe, 0x4f, 0x0e, - 0x7d, 0x00, 0x16, 0x48, 0x01, 0x4f, 0x98, 0xa5, 0x46, 0x69, 0xbb, 0x76, 0xeb, 0xed, 0x66, 0x12, - 0xdd, 0x6c, 0xba, 0xa6, 0x21, 0x2e, 0x6a, 0xb7, 0x47, 0x65, 0xef, 0x4c, 0x9b, 0x86, 0xf5, 0x37, - 0x03, 0x6c, 0xa8, 0x2a, 0xef, 0x12, 0x9b, 0x3c, 0x47, 0xdc, 0xdd, 0x27, 0x01, 0xf3, 0xc5, 0x37, - 0xb6, 0xd3, 0x02, 0x0b, 0xae, 0x46, 0x72, 0x24, 0x73, 0x90, 0xeb, 0x6a, 0x3b, 0x35, 0x8f, 0x22, - 0x1e, 0xb3, 0x5d, 0xd7, 0x85, 0xdb, 0x60, 0x39, 0xe7, 0xe1, 0xaa, 0x90, 0x54, 0x7e, 0x2b, 0xb6, - 0xc5, 0x94, 0x4d, 0x97, 0xd7, 0xab, 0xf3, 0xf7, 0xbf, 0x06, 0x58, 0xfe, 0xd8, 0x63, 0x1d, 0xe4, - 0x1d, 0x79, 0x48, 0xf4, 0x54, 0x07, 0x1c, 0xaa, 0xba, 0xe1, 0x24, 0x19, 0x3d, 0xda, 0xfc, 0x89, - 0xeb, 0x46, 0x89, 0xe9, 0x61, 0xf8, 0x21, 0x58, 0xc9, 0x86, 0x41, 0x96, 0xc7, 0xfa, 0xb6, 0x7b, - 0xab, 0xa7, 0x5f, 0x6d, 0x2d, 0xa5, 0x35, 0xd3, 0xd6, 0x39, 0xbd, 0x6f, 0x2f, 0xe1, 0x11, 0x82, - 0x0b, 0xeb, 0xa0, 0x46, 0x3b, 0xd8, 0x11, 0xe4, 0x99, 0x13, 0x0c, 0x7c, 0x5d, 0x02, 0x65, 0xbb, - 0x4a, 0x3b, 0xf8, 0x88, 0x3c, 0x7b, 0x34, 0xf0, 0xe1, 0x7b, 0xe0, 0x8d, 0x74, 0x45, 0x74, 0x22, - 0xe4, 0x39, 0x4a, 0x5e, 0xb9, 0x8b, 0xeb, 0xaa, 0x98, 0xb7, 0x57, 0xd3, 0xd3, 0x13, 0xe4, 0x29, - 0x65, 0xbb, 0xae, 0xcb, 0xad, 0x3f, 0xcf, 0x82, 0xd9, 0x43, 0xc4, 0x91, 0x2f, 0xe0, 0x31, 0x58, - 0x92, 0xc4, 0x0f, 0x3d, 0x24, 0x89, 0x13, 0x2f, 0x1a, 0xc9, 0x4d, 0x6f, 0xe8, 0x05, 0xa4, 0xb8, - 0xce, 0x35, 0x0b, 0x0b, 0x5c, 0xb4, 0xd3, 0x6c, 0x6b, 0xea, 0x91, 0x44, 0x92, 0xd8, 0x8b, 0x29, - 0x46, 0x4c, 0x84, 0xb7, 0x81, 0x29, 0xf9, 0x40, 0xc8, 0x7c, 0x05, 0xc8, 0x67, 0x5f, 0x1c, 0xeb, - 0x37, 0xd2, 0xf3, 0x78, 0x6a, 0x66, 0x33, 0xef, 0xfc, 0x69, 0x5f, 0xfa, 0x26, 0xd3, 0xfe, 0x08, - 0xac, 0xaa, 0x55, 0x69, 0x1c, 0xb3, 0x3c, 0x39, 0xe6, 0x8a, 0x92, 0x1f, 0x05, 0xfd, 0x04, 0xc0, - 0x48, 0xe0, 0x71, 0xcc, 0x99, 0xd7, 0xb0, 0x33, 0x12, 0x78, 0x14, 0xd2, 0x05, 0x9b, 0x42, 0x25, - 0x9f, 0xe3, 0x13, 0xa9, 0x77, 0x87, 0xd0, 0x23, 0x01, 0x15, 0xbd, 0x14, 0x7c, 0x76, 0x72, 0xf0, - 0x75, 0x0d, 0xf4, 0x50, 0xe1, 0xd8, 0x29, 0x4c, 0xa2, 0xa5, 0x0d, 0xea, 0xe7, 0x6b, 0xc9, 0x02, - 0x34, 0xa7, 0x03, 0xf4, 0xe6, 0x39, 0x10, 0x59, 0x94, 0x04, 0xb8, 0x5e, 0xd8, 0x71, 0x54, 0xd5, - 0x3b, 0xba, 0xe0, 0x1c, 0x4e, 0xba, 0x6a, 0x11, 0x40, 0xf1, 0xba, 0x43, 0x48, 0xb6, 0xa7, 0x25, - 0xb5, 0xa7, 0x96, 0xf4, 0x42, 0xf1, 0xd1, 0x20, 0x59, 0x66, 0xad, 0x7c, 0x15, 0xca, 0x7a, 0x88, - 0x5d, 0xc0, 0xfa, 0x88, 0x10, 0x55, 0xed, 0x85, 0x75, 0x88, 0x84, 0x0c, 0xf7, 0x74, 0xb7, 0x2c, - 0xd9, 0x8b, 0xd9, 0xea, 0x73, 0x57, 0x51, 0xe1, 0x01, 0xb8, 0xa6, 0xfa, 0x69, 0x56, 0x18, 0x0a, - 0x9c, 0x04, 0x62, 0x20, 0x9c, 0xbc, 0xff, 0xeb, 0x1d, 0xac, 0x64, 0xd7, 0x7d, 0xf4, 0xe2, 0x30, - 0xe1, 0x6b, 0xa7, 0x6c, 0x27, 0x19, 0xd7, 0xfd, 0x72, 0xa5, 0xb2, 0x5c, 0xb5, 0xbe, 0x0f, 0xaa, - 0xba, 0x2f, 0xec, 0xe2, 0xbe, 0xd0, 0x43, 0xc0, 0x75, 0x39, 0x11, 0x82, 0x08, 0xd3, 0x48, 0x86, - 0x40, 0x4a, 0xb0, 0x24, 0x58, 0xbf, 0xe8, 0xfb, 0x41, 0xc0, 0x27, 0x60, 0x2e, 0x24, 0x7a, 0xb9, - 0xd5, 0x82, 0xb5, 0x5b, 0x1f, 0x34, 0x27, 0xf8, 0xf0, 0x6b, 0x5e, 0x04, 0x68, 0xa7, 0x68, 0x16, - 0xcf, 0xbf, 0x5a, 0xc6, 0x16, 0x0a, 0x01, 0x4f, 0xc6, 0x95, 0xfe, 0xe8, 0xb5, 0x94, 0x8e, 0xe1, - 0xe5, 0x3a, 0x6f, 0x80, 0xda, 0x6e, 0x7c, 0xed, 0x1f, 0xab, 0x09, 0x77, 0xc6, 0x2d, 0xf3, 0x45, - 0xb7, 0xdc, 0x07, 0x8b, 0xc9, 0x2a, 0x78, 0xcc, 0x74, 0x6f, 0x83, 0xdf, 0x01, 0x20, 0xd9, 0x21, - 0x55, 0x4f, 0x8c, 0xa7, 0x43, 0x35, 0xa1, 0x1c, 0xb8, 0x23, 0x83, 0x7f, 0x7a, 0x64, 0xf0, 0x5b, - 0x36, 0x58, 0x3a, 0x11, 0xf8, 0x27, 0xe9, 0x77, 0xc2, 0xe3, 0x50, 0xc0, 0x2b, 0x60, 0x56, 0x95, - 0x63, 0x02, 0x54, 0xb6, 0x67, 0x22, 0x81, 0x0f, 0xf4, 0x80, 0xc8, 0xbf, 0x45, 0x58, 0xe8, 0x50, - 0x57, 0x98, 0xd3, 0x8d, 0xd2, 0x76, 0xd9, 0x5e, 0x1c, 0xe4, 0xe2, 0x07, 0xae, 0xb0, 0x7e, 0x0a, - 0x6a, 0x05, 0x40, 0xb8, 0x08, 0xa6, 0x33, 0xac, 0x69, 0xea, 0xc2, 0x3b, 0x60, 0x3d, 0x07, 0x1a, - 0xed, 0xe8, 0x31, 0x62, 0xd5, 0xbe, 0x9a, 0x31, 0x8c, 0x34, 0x75, 0x61, 0x3d, 0x06, 0x6b, 0x07, - 0x79, 0xff, 0xc8, 0xe6, 0xc5, 0xc8, 0x0d, 0x8d, 0xd1, 0xd5, 0x66, 0x13, 0x54, 0xb3, 0xcf, 0x73, - 0x7d, 0xfb, 0xb2, 0x9d, 0x13, 0x2c, 0x1f, 0x2c, 0x9f, 0x08, 0x7c, 0x44, 0x02, 0x37, 0x07, 0xbb, - 0xc0, 0x01, 0x7b, 0xe3, 0x40, 0x13, 0x7f, 0xd0, 0xe5, 0xea, 0x18, 0x58, 0x3f, 0x29, 0xee, 0x41, - 0x7a, 0xd6, 0x1f, 0x22, 0xdc, 0x27, 0x52, 0x40, 0x1b, 0x94, 0xf5, 0xbe, 0x13, 0x67, 0xd6, 0xed, - 0x0b, 0x33, 0x2b, 0xda, 0x69, 0x5e, 0x04, 0xb2, 0x8f, 0x24, 0x4a, 0xda, 0x80, 0xc6, 0xb2, 0xbe, - 0x07, 0x56, 0x1f, 0x22, 0x39, 0xe0, 0xc4, 0x1d, 0x89, 0xf1, 0x32, 0x28, 0xa9, 0xf8, 0x19, 0x3a, - 0x7e, 0xea, 0xd1, 0xfa, 0x83, 0x01, 0xcc, 0xbb, 0x2f, 0x42, 0xc6, 0x25, 0x71, 0xcf, 0x78, 0xe4, - 0x12, 0xf7, 0xf6, 0xc1, 0xaa, 0x72, 0x96, 0x20, 0x81, 0xeb, 0x64, 0xf7, 0x8c, 0xe3, 0x58, 0xbb, - 0xf5, 0xfe, 0x44, 0xd5, 0x31, 0xae, 0x2e, 0xb9, 0xc0, 0x4a, 0x34, 0x46, 0x17, 0xd6, 0xaf, 0x0d, - 0x60, 0x3e, 0x20, 0xc3, 0x5d, 0x21, 0x68, 0x37, 0xf0, 0x49, 0x20, 0x55, 0x3b, 0x45, 0x98, 0xa8, - 0x47, 0xf8, 0x16, 0x58, 0xc8, 0xba, 0x94, 0x9e, 0xda, 0x86, 0x9e, 0xda, 0xf3, 0x29, 0x51, 0x15, - 0x18, 0xbc, 0x03, 0x40, 0xc8, 0x49, 0xe4, 0x60, 0xa7, 0x4f, 0x86, 0x49, 0x14, 0x37, 0x8b, 0xd3, - 0x38, 0xfe, 0xf1, 0xa4, 0x79, 0x38, 0xe8, 0x78, 0x14, 0x3f, 0x20, 0x43, 0xbb, 0xa2, 0xf8, 0xdb, - 0x0f, 0xc8, 0x50, 0xad, 0x5f, 0x7a, 0x09, 0xd6, 0x23, 0xb4, 0x64, 0xc7, 0x2f, 0xd6, 0x6f, 0x0d, - 0x70, 0x35, 0x0b, 0x47, 0x9a, 0xae, 0x87, 0x83, 0x8e, 0x92, 0xb8, 0xc4, 0x6f, 0x67, 0xac, 0x9d, - 0x3e, 0xc7, 0xda, 0x0f, 0xc1, 0x7c, 0x56, 0x20, 0xca, 0xde, 0xd2, 0x04, 0xf6, 0xd6, 0x52, 0x89, - 0x07, 0x64, 0x68, 0xfd, 0xa2, 0x60, 0xdb, 0xde, 0xb0, 0xd0, 0xfb, 0xf8, 0x2b, 0x6c, 0xcb, 0xd4, - 0x16, 0x6d, 0xc3, 0x45, 0xf9, 0x33, 0x17, 0x28, 0x9d, 0xbd, 0x80, 0xf5, 0x7b, 0x03, 0xac, 0x15, - 0xb5, 0x8a, 0x63, 0x76, 0xc8, 0x07, 0x01, 0xb9, 0x4c, 0x7b, 0x5e, 0x7e, 0xd3, 0xc5, 0xf2, 0x7b, - 0x02, 0x16, 0x47, 0x8c, 0x12, 0x89, 0x37, 0xde, 0x9d, 0x28, 0xc7, 0x0a, 0xdd, 0xd5, 0x5e, 0x28, - 0xde, 0x43, 0x58, 0xbf, 0x31, 0x00, 0x3c, 0x3b, 0xae, 0xe0, 0x0f, 0x00, 0x1c, 0x19, 0x7a, 0xc5, - 0x9c, 0x5a, 0x0e, 0x0b, 0x63, 0x4e, 0x7b, 0x23, 0xcb, 0x8d, 0xe9, 0x42, 0x6e, 0xc0, 0x1f, 0x02, - 0x10, 0xea, 0xc0, 0x4c, 0x1c, 0xbd, 0x6a, 0x98, 0x3e, 0x5a, 0xbf, 0x32, 0xf2, 0xf1, 0x17, 0x8f, - 0x72, 0xb1, 0xeb, 0x79, 0xc9, 0xf7, 0x02, 0x0c, 0xc1, 0x5c, 0xbc, 0x2d, 0x88, 0xa4, 0x5f, 0x6c, - 0x9e, 0xbb, 0x17, 0xec, 0x13, 0xac, 0x57, 0x83, 0xdb, 0xaa, 0xa4, 0xfe, 0xf4, 0xf5, 0xd6, 0x8d, - 0x2e, 0x95, 0xbd, 0x41, 0xa7, 0x89, 0x99, 0x9f, 0xfc, 0x7e, 0x97, 0xfc, 0xbb, 0x29, 0xdc, 0x7e, - 0x4b, 0x0e, 0x43, 0x22, 0x52, 0x19, 0xf1, 0xc7, 0xff, 0xfc, 0xe5, 0x1d, 0xc3, 0x4e, 0xd5, 0xec, - 0x3d, 0xf9, 0xe2, 0xb4, 0x6e, 0x7c, 0x79, 0x5a, 0x37, 0xfe, 0x7d, 0x5a, 0x37, 0x3e, 0x7d, 0x59, - 0x9f, 0xfa, 0xf2, 0x65, 0x7d, 0xea, 0x5f, 0x2f, 0xeb, 0x53, 0x3f, 0xfb, 0xe0, 0x2c, 0x68, 0x1e, - 0x93, 0x9b, 0xd9, 0xcf, 0xab, 0xd1, 0xfb, 0xad, 0x17, 0xa3, 0x3f, 0xde, 0x6a, 0x7d, 0x9d, 0x59, - 0xdd, 0x3d, 0xdf, 0xfb, 0x5f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xd0, 0xcc, 0x39, 0x68, 0xed, 0x15, + // 2098 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x58, 0xcb, 0x6f, 0x1b, 0xc7, + 0x19, 0xd7, 0x8a, 0x94, 0x44, 0x0e, 0xf5, 0x1c, 0xc9, 0xf6, 0x4a, 0x51, 0x29, 0x7a, 0xd3, 0xb8, + 0x6c, 0x5c, 0x93, 0x91, 0x83, 0x00, 0x86, 0xdb, 0x20, 0x90, 0x28, 0x27, 0x96, 0x5d, 0xdb, 0xca, + 0x4a, 0x95, 0xd1, 0xf6, 0xb0, 0x18, 0xce, 0x8e, 0xc9, 0x81, 0x76, 0x77, 0xd6, 0x33, 0xc3, 0xb5, + 0x79, 0xe9, 0xb1, 0xe8, 0xa5, 0x40, 0x5a, 0xa0, 0x40, 0xd0, 0x4b, 0xd3, 0x9e, 0x8a, 0x1e, 0x8a, + 0x1e, 0xfa, 0x17, 0xf4, 0x14, 0xf4, 0xd2, 0x1c, 0x7b, 0x4a, 0x0a, 0xfb, 0xd0, 0x43, 0xff, 0x89, + 0x62, 0x66, 0x9f, 0xa4, 0x1e, 0xa6, 0x91, 0xe4, 0x22, 0xed, 0x7e, 0x8f, 0xdf, 0xf7, 0xcd, 0x7c, + 0xcf, 0x25, 0xb8, 0x49, 0x03, 0x49, 0x38, 0xee, 0x23, 0x1a, 0x38, 0x82, 0xe0, 0x01, 0xa7, 0x72, + 0xd8, 0xc6, 0x38, 0x6a, 0x87, 0x9c, 0x45, 0xd4, 0x25, 0xbc, 0x1d, 0x6d, 0x67, 0xcf, 0xad, 0x90, + 0x33, 0xc9, 0xe0, 0x9b, 0x67, 0xe8, 0xb4, 0x30, 0x8e, 0x5a, 0x99, 0x5c, 0xb4, 0xbd, 0xf1, 0xd6, + 0x79, 0xc0, 0xd1, 0x76, 0xfb, 0x19, 0xe5, 0x24, 0xc6, 0xda, 0x58, 0xeb, 0xb1, 0x1e, 0xd3, 0x8f, + 0x6d, 0xf5, 0x94, 0x50, 0xb7, 0x7a, 0x8c, 0xf5, 0x3c, 0xd2, 0xd6, 0x6f, 0xdd, 0xc1, 0x93, 0xb6, + 0xa4, 0x3e, 0x11, 0x12, 0xf9, 0x61, 0x22, 0x50, 0x1f, 0x17, 0x70, 0x07, 0x1c, 0x49, 0xca, 0x82, + 0x14, 0x80, 0x76, 0x71, 0x1b, 0x33, 0x4e, 0xda, 0xd8, 0xa3, 0x24, 0x90, 0xca, 0x6a, 0xfc, 0x94, + 0x08, 0xb4, 0x95, 0x80, 0x47, 0x7b, 0x7d, 0x19, 0x93, 0x45, 0x5b, 0x92, 0xc0, 0x25, 0xdc, 0xa7, + 0xb1, 0x70, 0xfe, 0x96, 0x28, 0x6c, 0x16, 0xf8, 0x98, 0x0f, 0x43, 0xc9, 0xda, 0x27, 0x64, 0x28, + 0x12, 0xee, 0x35, 0xcc, 0x84, 0xcf, 0x44, 0x9b, 0xa8, 0xf3, 0x07, 0x98, 0xb4, 0xa3, 0xed, 0x2e, + 0x91, 0x68, 0x3b, 0x23, 0xa4, 0x7e, 0x27, 0x72, 0x5d, 0x24, 0x72, 0x19, 0xcc, 0x68, 0xea, 0xf7, + 0x7a, 0xcc, 0x77, 0xe2, 0x1b, 0x89, 0x5f, 0x12, 0xd6, 0x0a, 0xf2, 0x69, 0xc0, 0xda, 0xfa, 0x6f, + 0x4c, 0xb2, 0x7e, 0x5b, 0x05, 0x66, 0x87, 0x05, 0x62, 0xe0, 0x13, 0xbe, 0xe3, 0xba, 0x54, 0x5d, + 0xc0, 0x01, 0x67, 0x21, 0x13, 0xc8, 0x83, 0x6b, 0x60, 0x46, 0x52, 0xe9, 0x11, 0xd3, 0x68, 0x18, + 0xcd, 0xaa, 0x1d, 0xbf, 0xc0, 0x06, 0xa8, 0xb9, 0x44, 0x60, 0x4e, 0x43, 0x25, 0x6c, 0x4e, 0x6b, + 0x5e, 0x91, 0x04, 0xd7, 0x41, 0x25, 0x8e, 0x1a, 0x75, 0xcd, 0x92, 0x66, 0xcf, 0xe9, 0xf7, 0x7d, + 0x17, 0x7e, 0x04, 0x16, 0x69, 0x40, 0x25, 0x45, 0x9e, 0xd3, 0x27, 0xea, 0xee, 0xcc, 0x72, 0xc3, + 0x68, 0xd6, 0x6e, 0x6e, 0xb4, 0x68, 0x17, 0xb7, 0xd4, 0x75, 0xb7, 0x92, 0x4b, 0x8e, 0xb6, 0x5b, + 0x77, 0xb5, 0xc4, 0x6e, 0xf9, 0xf3, 0x2f, 0xb7, 0xa6, 0xec, 0x85, 0x44, 0x2f, 0x26, 0xc2, 0xab, + 0x60, 0xbe, 0x47, 0x02, 0x22, 0xa8, 0x70, 0xfa, 0x48, 0xf4, 0xcd, 0x99, 0x86, 0xd1, 0x9c, 0xb7, + 0x6b, 0x09, 0xed, 0x2e, 0x12, 0x7d, 0xb8, 0x05, 0x6a, 0x5d, 0x1a, 0x20, 0x3e, 0x8c, 0x25, 0x66, + 0xb5, 0x04, 0x88, 0x49, 0x5a, 0xa0, 0x03, 0x80, 0x08, 0xd1, 0xb3, 0xc0, 0x51, 0xb9, 0x61, 0xce, + 0x25, 0x8e, 0xc4, 0x79, 0xd1, 0x4a, 0xf3, 0xa2, 0x75, 0x94, 0x26, 0xce, 0x6e, 0x45, 0x39, 0xf2, + 0xc9, 0x57, 0x5b, 0x86, 0x5d, 0xd5, 0x7a, 0x8a, 0x03, 0x1f, 0x82, 0xe5, 0x41, 0xd0, 0x65, 0x81, + 0x4b, 0x83, 0x9e, 0x13, 0x12, 0x4e, 0x99, 0x6b, 0x56, 0x34, 0xd4, 0xfa, 0x29, 0xa8, 0xbd, 0x24, + 0xc5, 0x62, 0xa4, 0x4f, 0x15, 0xd2, 0x52, 0xa6, 0x7c, 0xa0, 0x75, 0xe1, 0xc7, 0x00, 0x62, 0x1c, + 0x69, 0x97, 0xd8, 0x40, 0xa6, 0x88, 0xd5, 0xc9, 0x11, 0x97, 0x31, 0x8e, 0x8e, 0x62, 0xed, 0x04, + 0xf2, 0xe7, 0xe0, 0x8a, 0xe4, 0x28, 0x10, 0x4f, 0x08, 0x1f, 0xc7, 0x05, 0x93, 0xe3, 0x5e, 0x4a, + 0x31, 0x46, 0xc1, 0xef, 0x82, 0x06, 0x4e, 0x12, 0xc8, 0xe1, 0xc4, 0xa5, 0x42, 0x72, 0xda, 0x1d, + 0x28, 0x5d, 0xe7, 0x09, 0x47, 0x58, 0xe7, 0x48, 0x4d, 0x27, 0x41, 0x3d, 0x95, 0xb3, 0x47, 0xc4, + 0x3e, 0x4c, 0xa4, 0xe0, 0x23, 0xf0, 0xdd, 0xae, 0xc7, 0xf0, 0x89, 0x50, 0xce, 0x39, 0x23, 0x48, + 0xda, 0xb4, 0x4f, 0x85, 0x50, 0x68, 0xf3, 0x0d, 0xa3, 0x59, 0xb2, 0xaf, 0xc6, 0xb2, 0x07, 0x84, + 0xef, 0x15, 0x24, 0x8f, 0x0a, 0x82, 0xf0, 0x06, 0x80, 0x7d, 0x2a, 0x24, 0xe3, 0x14, 0x23, 0xcf, + 0x21, 0x81, 0xe4, 0x94, 0x08, 0x73, 0x41, 0xab, 0xaf, 0xe4, 0x9c, 0x3b, 0x31, 0x03, 0xde, 0x03, + 0x57, 0xcf, 0x35, 0xea, 0xe0, 0x3e, 0x0a, 0x02, 0xe2, 0x99, 0x8b, 0xfa, 0x28, 0x5b, 0xee, 0x39, + 0x36, 0x3b, 0xb1, 0x18, 0x5c, 0x05, 0x33, 0x92, 0x85, 0xce, 0x43, 0x73, 0xa9, 0x61, 0x34, 0x17, + 0xec, 0xb2, 0x64, 0xe1, 0x43, 0xf8, 0x0e, 0x58, 0x8b, 0x90, 0x47, 0x5d, 0x24, 0x19, 0x17, 0x4e, + 0xc8, 0x9e, 0x11, 0xee, 0x60, 0x14, 0x9a, 0xcb, 0x5a, 0x06, 0xe6, 0xbc, 0x03, 0xc5, 0xea, 0xa0, + 0x10, 0xbe, 0x0d, 0x56, 0x32, 0xaa, 0x23, 0x88, 0xd4, 0xe2, 0x2b, 0x5a, 0x7c, 0x29, 0x63, 0x1c, + 0x12, 0xa9, 0x64, 0x37, 0x41, 0x15, 0x79, 0x1e, 0x7b, 0xe6, 0x51, 0x21, 0x4d, 0xd8, 0x28, 0x35, + 0xab, 0x76, 0x4e, 0x80, 0x1b, 0xa0, 0xe2, 0x92, 0x60, 0xa8, 0x99, 0xab, 0x9a, 0x99, 0xbd, 0xc3, + 0x37, 0x40, 0xd5, 0x57, 0x3d, 0x56, 0xa2, 0x13, 0x62, 0xae, 0x35, 0x8c, 0x66, 0xd9, 0xae, 0xf8, + 0x34, 0x38, 0x54, 0xef, 0xaa, 0x98, 0x7d, 0xf4, 0xdc, 0xe1, 0x28, 0x38, 0x31, 0x2f, 0x69, 0xcb, + 0x73, 0x3e, 0x7a, 0x6e, 0xa3, 0xe0, 0x04, 0xb6, 0xc0, 0xaa, 0x36, 0xe0, 0xd0, 0x40, 0x85, 0x30, + 0x22, 0x4e, 0x84, 0x3c, 0x61, 0x5e, 0x6e, 0x18, 0xcd, 0x8a, 0xbd, 0xa2, 0x59, 0xfb, 0x09, 0xe7, + 0x18, 0x79, 0xe2, 0xf6, 0xb5, 0x5f, 0x7d, 0xb6, 0x35, 0xf5, 0xe9, 0x67, 0x5b, 0x53, 0xff, 0xfc, + 0xfb, 0x8d, 0x8d, 0xa4, 0x33, 0xf5, 0x58, 0xd4, 0x4a, 0xba, 0x58, 0xab, 0xc3, 0x02, 0x49, 0x02, + 0x69, 0xfd, 0xcb, 0x00, 0x57, 0x3a, 0x59, 0xae, 0xf8, 0x2c, 0x42, 0xde, 0xb7, 0xd9, 0x93, 0x76, + 0x40, 0x55, 0xa8, 0x60, 0xe9, 0x2e, 0x50, 0x7e, 0x8d, 0x2e, 0x50, 0x51, 0x6a, 0x8a, 0x71, 0xbb, + 0xfe, 0x8a, 0x13, 0xfd, 0xb2, 0x04, 0x36, 0xd3, 0x13, 0x3d, 0x60, 0x2e, 0x7d, 0x42, 0x31, 0xfa, + 0xb6, 0x5b, 0x6d, 0x96, 0x82, 0xe5, 0x09, 0x52, 0x70, 0xe6, 0xf5, 0x52, 0x70, 0x76, 0x82, 0x14, + 0x9c, 0xbb, 0x28, 0x05, 0x2b, 0x17, 0xa5, 0x60, 0xf5, 0x82, 0x14, 0x04, 0x13, 0xa5, 0x60, 0xed, + 0x9c, 0x14, 0xb4, 0xfe, 0x60, 0x80, 0xb5, 0x3b, 0x4f, 0x07, 0x34, 0x62, 0xdf, 0x50, 0x00, 0xee, + 0x83, 0x05, 0x52, 0xc0, 0x13, 0x66, 0xa9, 0x51, 0x6a, 0xd6, 0x6e, 0xbe, 0xd5, 0x4a, 0xb2, 0x21, + 0x9b, 0xde, 0x69, 0x4a, 0x14, 0xad, 0xdb, 0xa3, 0xba, 0xb7, 0xa7, 0x4d, 0xc3, 0xfa, 0x87, 0x01, + 0x36, 0x54, 0x17, 0xe9, 0x11, 0x9b, 0x3c, 0x43, 0xdc, 0xdd, 0x23, 0x01, 0xf3, 0xc5, 0xd7, 0xf6, + 0xd3, 0x02, 0x0b, 0xae, 0x46, 0x72, 0x24, 0x73, 0x90, 0xeb, 0x6a, 0x3f, 0xb5, 0x8c, 0x22, 0x1e, + 0xb1, 0x1d, 0xd7, 0x85, 0x4d, 0xb0, 0x9c, 0xcb, 0x70, 0x55, 0x78, 0xaa, 0x1e, 0x94, 0xd8, 0x62, + 0x2a, 0xa6, 0xcb, 0xf1, 0xd5, 0xf9, 0xfe, 0x3f, 0x03, 0x2c, 0x7f, 0xe4, 0xb1, 0x2e, 0xf2, 0x0e, + 0x3d, 0x24, 0xfa, 0xaa, 0xc3, 0x0e, 0x55, 0x9d, 0x71, 0x92, 0x8c, 0x36, 0xed, 0xfe, 0xc4, 0x75, + 0xa6, 0xd4, 0xf4, 0xb0, 0xfd, 0x00, 0xac, 0x64, 0xc3, 0x26, 0xcb, 0x7b, 0x7d, 0xda, 0xdd, 0xd5, + 0x17, 0x5f, 0x6e, 0x2d, 0xa5, 0x35, 0xd6, 0xd1, 0x35, 0xb0, 0x67, 0x2f, 0xe1, 0x11, 0x82, 0x0b, + 0xeb, 0xa0, 0x46, 0xbb, 0xd8, 0x11, 0xe4, 0xa9, 0x13, 0x0c, 0x7c, 0x5d, 0x32, 0x65, 0xbb, 0x4a, + 0xbb, 0xf8, 0x90, 0x3c, 0x7d, 0x38, 0xf0, 0xe1, 0xbb, 0xe0, 0x72, 0xba, 0x82, 0xaa, 0x4c, 0x72, + 0x94, 0xbe, 0xba, 0x2e, 0xae, 0xab, 0x68, 0xde, 0x5e, 0x4d, 0xb9, 0xc7, 0xc8, 0x53, 0xc6, 0x76, + 0x5c, 0x97, 0x5b, 0x7f, 0x9d, 0x05, 0xb3, 0x07, 0x88, 0x23, 0x5f, 0xc0, 0x23, 0xb0, 0x24, 0x89, + 0x1f, 0x7a, 0x48, 0x12, 0x27, 0x5e, 0x64, 0x92, 0x93, 0x5e, 0xd7, 0x0b, 0x4e, 0x71, 0x5d, 0x6c, + 0x15, 0x16, 0xc4, 0x68, 0xbb, 0xd5, 0xd1, 0xd4, 0x43, 0x89, 0x24, 0xb1, 0x17, 0x53, 0x8c, 0x98, + 0x08, 0x6f, 0x01, 0x53, 0xf2, 0x81, 0x90, 0xf9, 0x8a, 0x91, 0xcf, 0xd6, 0x38, 0xd6, 0x97, 0x53, + 0x7e, 0x3c, 0x95, 0xb3, 0x99, 0x7a, 0xf6, 0x36, 0x51, 0xfa, 0x3a, 0xdb, 0xc4, 0x21, 0x58, 0x55, + 0xab, 0xd8, 0x38, 0x66, 0x79, 0x72, 0xcc, 0x15, 0xa5, 0x3f, 0x0a, 0xfa, 0x31, 0x80, 0x91, 0xc0, + 0xe3, 0x98, 0x33, 0xaf, 0xe1, 0x67, 0x24, 0xf0, 0x28, 0xa4, 0x0b, 0x36, 0x85, 0x4a, 0x3e, 0xc7, + 0x27, 0x52, 0xef, 0x26, 0xa1, 0x47, 0x02, 0x2a, 0xfa, 0x29, 0xf8, 0xec, 0xe4, 0xe0, 0xeb, 0x1a, + 0xe8, 0x81, 0xc2, 0xb1, 0x53, 0x98, 0xc4, 0x4a, 0x07, 0xd4, 0xcf, 0xb6, 0x92, 0x05, 0x68, 0x4e, + 0x07, 0xe8, 0x8d, 0x33, 0x20, 0xb2, 0x28, 0x09, 0x70, 0xad, 0xb0, 0x43, 0xa9, 0xaa, 0x77, 0x74, + 0xc1, 0x39, 0x9c, 0xf4, 0xd4, 0xa2, 0x81, 0xe2, 0x75, 0x8a, 0x90, 0x6c, 0x0f, 0x4c, 0x6a, 0x4f, + 0x7d, 0x04, 0x14, 0x8a, 0x8f, 0x06, 0xc9, 0xb2, 0x6c, 0xe5, 0xab, 0x56, 0xd6, 0x43, 0xec, 0x02, + 0xd6, 0x87, 0x84, 0xa8, 0x6a, 0x2f, 0xac, 0x5b, 0x24, 0x64, 0xb8, 0xaf, 0xbb, 0x6b, 0xc9, 0x5e, + 0xcc, 0x56, 0xab, 0x3b, 0x8a, 0x0a, 0xf7, 0xc1, 0x55, 0xd5, 0x7f, 0xb3, 0xc2, 0x50, 0xe0, 0x24, + 0x10, 0x03, 0xe1, 0xe4, 0xf3, 0x42, 0xb7, 0xdc, 0x92, 0x5d, 0xf7, 0xd1, 0xf3, 0x83, 0x44, 0xae, + 0x93, 0x8a, 0x1d, 0x67, 0x52, 0xf7, 0xca, 0x95, 0xca, 0x72, 0xd5, 0xfa, 0x3e, 0xa8, 0xea, 0xbe, + 0xb0, 0x83, 0x4f, 0x84, 0x1e, 0x1a, 0xae, 0xcb, 0x89, 0x10, 0x44, 0x98, 0x46, 0x32, 0x34, 0x52, + 0x82, 0x25, 0xc1, 0xfa, 0x79, 0xdf, 0x27, 0x02, 0x3e, 0x06, 0x73, 0x21, 0xd1, 0xcb, 0xb3, 0x56, + 0xac, 0xdd, 0x7c, 0xbf, 0x35, 0xc1, 0x87, 0x65, 0xeb, 0x3c, 0x40, 0x3b, 0x45, 0xb3, 0x78, 0xfe, + 0x55, 0x34, 0xb6, 0x80, 0x08, 0x78, 0x3c, 0x6e, 0xf4, 0x47, 0xaf, 0x65, 0x74, 0x0c, 0x2f, 0xb7, + 0x79, 0x1d, 0xd4, 0x76, 0xe2, 0x63, 0xff, 0x58, 0x4d, 0xc4, 0x53, 0xd7, 0x32, 0x5f, 0xbc, 0x96, + 0x7b, 0x60, 0x31, 0x59, 0x35, 0x8f, 0x98, 0xee, 0x6d, 0xf0, 0x3b, 0x00, 0x24, 0x3b, 0xaa, 0xea, + 0x89, 0xf1, 0x74, 0xa8, 0x26, 0x94, 0x7d, 0x77, 0x64, 0x51, 0x98, 0x1e, 0x59, 0x14, 0x2c, 0x1b, + 0x2c, 0x1d, 0x0b, 0xfc, 0x93, 0xf4, 0x3b, 0xe4, 0x51, 0x28, 0xe0, 0x25, 0x30, 0xab, 0xca, 0x31, + 0x01, 0x2a, 0xdb, 0x33, 0x91, 0xc0, 0xfb, 0x7a, 0x40, 0xe4, 0xdf, 0x3a, 0x2c, 0x74, 0xa8, 0x2b, + 0xcc, 0xe9, 0x46, 0xa9, 0x59, 0xb6, 0x17, 0x07, 0xb9, 0xfa, 0xbe, 0x2b, 0xac, 0x9f, 0x82, 0x5a, + 0x01, 0x10, 0x2e, 0x82, 0xe9, 0x0c, 0x6b, 0x9a, 0xba, 0xf0, 0x36, 0x58, 0xcf, 0x81, 0x46, 0x3b, + 0x7a, 0x8c, 0x58, 0xb5, 0xaf, 0x64, 0x02, 0x23, 0x4d, 0x5d, 0x58, 0x8f, 0xc0, 0xda, 0x7e, 0xde, + 0x3f, 0xb2, 0x79, 0x31, 0x72, 0x42, 0x63, 0x74, 0x15, 0xda, 0x04, 0xd5, 0xec, 0xf3, 0x5f, 0x9f, + 0xbe, 0x6c, 0xe7, 0x04, 0xcb, 0x07, 0xcb, 0xc7, 0x02, 0x1f, 0x92, 0xc0, 0xcd, 0xc1, 0xce, 0xb9, + 0x80, 0xdd, 0x71, 0xa0, 0x89, 0x3f, 0x18, 0x73, 0x73, 0x0c, 0xac, 0x1f, 0x17, 0xf7, 0x26, 0x3d, + 0xeb, 0x0f, 0x10, 0x3e, 0x21, 0x52, 0x40, 0x1b, 0x94, 0xf5, 0x7e, 0x14, 0x67, 0xd6, 0xad, 0x73, + 0x33, 0x2b, 0xda, 0x6e, 0x9d, 0x07, 0xb2, 0x87, 0x24, 0x4a, 0xda, 0x80, 0xc6, 0xb2, 0xbe, 0x07, + 0x56, 0x1f, 0x20, 0x39, 0xe0, 0xc4, 0x1d, 0x89, 0xf1, 0x32, 0x28, 0xa9, 0xf8, 0x19, 0x3a, 0x7e, + 0xea, 0xd1, 0xfa, 0x93, 0x01, 0xcc, 0x3b, 0xcf, 0x43, 0xc6, 0x25, 0x71, 0x4f, 0xdd, 0xc8, 0x05, + 0xd7, 0x7b, 0x02, 0x56, 0xd5, 0x65, 0x09, 0x12, 0xb8, 0x4e, 0x76, 0xce, 0x38, 0x8e, 0xb5, 0x9b, + 0xef, 0x4d, 0x54, 0x1d, 0xe3, 0xe6, 0x92, 0x03, 0xac, 0x44, 0x63, 0x74, 0x61, 0xfd, 0xc6, 0x00, + 0xe6, 0x7d, 0x32, 0xdc, 0x11, 0x82, 0xf6, 0x02, 0x9f, 0x04, 0x52, 0xb5, 0x53, 0x84, 0x89, 0x7a, + 0x84, 0x6f, 0x82, 0x85, 0xac, 0x4b, 0xe9, 0xa9, 0x6d, 0xe8, 0xa9, 0x3d, 0x9f, 0x12, 0x55, 0x81, + 0xc1, 0xdb, 0x00, 0x84, 0x9c, 0x44, 0x0e, 0x76, 0x4e, 0xc8, 0x30, 0x89, 0xe2, 0x66, 0x71, 0x1a, + 0xc7, 0x3f, 0xce, 0xb4, 0x0e, 0x06, 0x5d, 0x8f, 0xe2, 0xfb, 0x64, 0x68, 0x57, 0x94, 0x7c, 0xe7, + 0x3e, 0x19, 0xaa, 0xf5, 0x4b, 0x2f, 0xcd, 0x7a, 0x84, 0x96, 0xec, 0xf8, 0xc5, 0xfa, 0xbd, 0x01, + 0xae, 0x64, 0xe1, 0x48, 0xd3, 0xf5, 0x60, 0xd0, 0x55, 0x1a, 0x17, 0xdc, 0xdb, 0x29, 0x6f, 0xa7, + 0xcf, 0xf0, 0xf6, 0x03, 0x30, 0x9f, 0x15, 0x88, 0xf2, 0xb7, 0x34, 0x81, 0xbf, 0xb5, 0x54, 0xe3, + 0x3e, 0x19, 0x5a, 0xbf, 0x28, 0xf8, 0xb6, 0x3b, 0x2c, 0xf4, 0x3e, 0xfe, 0x0a, 0xdf, 0x32, 0xb3, + 0x45, 0xdf, 0x70, 0x51, 0xff, 0xd4, 0x01, 0x4a, 0xa7, 0x0f, 0x60, 0xfd, 0xd1, 0x00, 0x6b, 0x45, + 0xab, 0xe2, 0x88, 0x1d, 0xf0, 0x41, 0x40, 0x2e, 0xb2, 0x9e, 0x97, 0xdf, 0x74, 0xb1, 0xfc, 0x1e, + 0x83, 0xc5, 0x11, 0xa7, 0x44, 0x72, 0x1b, 0xef, 0x4c, 0x94, 0x63, 0x85, 0xee, 0x6a, 0x2f, 0x14, + 0xcf, 0x21, 0xac, 0xdf, 0x19, 0x00, 0x9e, 0x1e, 0x57, 0xf0, 0x07, 0x00, 0x8e, 0x0c, 0xbd, 0x62, + 0x4e, 0x2d, 0x87, 0x85, 0x31, 0xa7, 0x6f, 0x23, 0xcb, 0x8d, 0xe9, 0x42, 0x6e, 0xc0, 0x1f, 0x02, + 0x10, 0xea, 0xc0, 0x4c, 0x1c, 0xbd, 0x6a, 0x98, 0x3e, 0x5a, 0xbf, 0x36, 0xf2, 0xf1, 0x17, 0x8f, + 0x72, 0xb1, 0xe3, 0x79, 0xc9, 0xf7, 0x02, 0x0c, 0xc1, 0x5c, 0xbc, 0x2d, 0x88, 0xa4, 0x5f, 0x6c, + 0x9e, 0xb9, 0x17, 0xec, 0x11, 0xac, 0x57, 0x83, 0x5b, 0xaa, 0xa4, 0xfe, 0xf2, 0xd5, 0xd6, 0xf5, + 0x1e, 0x95, 0xfd, 0x41, 0xb7, 0x85, 0x99, 0x9f, 0xfc, 0x3e, 0x98, 0xfc, 0xbb, 0x21, 0xdc, 0x93, + 0xb6, 0x1c, 0x86, 0x44, 0xa4, 0x3a, 0xe2, 0xcf, 0xff, 0xfd, 0xdb, 0xdb, 0x86, 0x9d, 0x9a, 0xd9, + 0x7d, 0xfc, 0xf9, 0x8b, 0xba, 0xf1, 0xc5, 0x8b, 0xba, 0xf1, 0x9f, 0x17, 0x75, 0xe3, 0x93, 0x97, + 0xf5, 0xa9, 0x2f, 0x5e, 0xd6, 0xa7, 0xfe, 0xfd, 0xb2, 0x3e, 0xf5, 0xb3, 0xf7, 0x4f, 0x83, 0xe6, + 0x31, 0xb9, 0x91, 0xfd, 0x7c, 0x1b, 0xbd, 0xd7, 0x7e, 0x3e, 0xfa, 0xe3, 0xb0, 0xb6, 0xd7, 0x9d, + 0xd5, 0xdd, 0xf3, 0xdd, 0xff, 0x07, 0x00, 0x00, 0xff, 0xff, 0x94, 0x29, 0x12, 0xdc, 0x4d, 0x16, 0x00, 0x00, } @@ -1871,6 +1884,18 @@ func (m *ConsumerAdditionProposal) MarshalToSizedBuffer(dAtA []byte) (int, error _ = i var l int _ = l + if m.AllowInactiveVals { + i-- + if m.AllowInactiveVals { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xb0 + } if m.MaxRank != 0 { i = encodeVarintProvider(dAtA, i, uint64(m.MaxRank)) i-- @@ -2102,6 +2127,16 @@ func (m *ConsumerModificationProposal) MarshalToSizedBuffer(dAtA []byte) (int, e _ = i var l int _ = l + if m.AllowInactiveVals { + i-- + if m.AllowInactiveVals { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x58 + } if m.MaxRank != 0 { i = encodeVarintProvider(dAtA, i, uint64(m.MaxRank)) i-- @@ -3236,6 +3271,9 @@ func (m *ConsumerAdditionProposal) Size() (n int) { if m.MaxRank != 0 { n += 2 + sovProvider(uint64(m.MaxRank)) } + if m.AllowInactiveVals { + n += 3 + } return n } @@ -3307,6 +3345,9 @@ func (m *ConsumerModificationProposal) Size() (n int) { if m.MaxRank != 0 { n += 1 + sovProvider(uint64(m.MaxRank)) } + if m.AllowInactiveVals { + n += 2 + } return n } @@ -4357,6 +4398,26 @@ func (m *ConsumerAdditionProposal) Unmarshal(dAtA []byte) error { break } } + case 22: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AllowInactiveVals", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowProvider + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.AllowInactiveVals = bool(v != 0) default: iNdEx = preIndex skippy, err := skipProvider(dAtA[iNdEx:]) @@ -4841,6 +4902,26 @@ func (m *ConsumerModificationProposal) Unmarshal(dAtA []byte) error { break } } + case 11: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AllowInactiveVals", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowProvider + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.AllowInactiveVals = bool(v != 0) default: iNdEx = preIndex skippy, err := skipProvider(dAtA[iNdEx:]) diff --git a/x/ccv/provider/types/tx.pb.go b/x/ccv/provider/types/tx.pb.go index e0d2693400..457a117b96 100644 --- a/x/ccv/provider/types/tx.pb.go +++ b/x/ccv/provider/types/tx.pb.go @@ -451,6 +451,8 @@ type MsgConsumerAddition struct { MinStake uint64 `protobuf:"varint,19,opt,name=min_stake,json=minStake,proto3" json:"min_stake,omitempty"` // Corresponds to the maximal rank in the provider chain validator set that a validator can have to validate on the consumer chain. MaxRank uint32 `protobuf:"varint,20,opt,name=max_rank,json=maxRank,proto3" json:"max_rank,omitempty"` + // Corresponds to whether inactive validators are allowed to validate the consumer chain. + AllowInactiveVals bool `protobuf:"varint,21,opt,name=allow_inactive_vals,json=allowInactiveVals,proto3" json:"allow_inactive_vals,omitempty"` } func (m *MsgConsumerAddition) Reset() { *m = MsgConsumerAddition{} } @@ -626,6 +628,13 @@ func (m *MsgConsumerAddition) GetMaxRank() uint32 { return 0 } +func (m *MsgConsumerAddition) GetAllowInactiveVals() bool { + if m != nil { + return m.AllowInactiveVals + } + return false +} + // MsgConsumerAdditionResponse defines response type for MsgConsumerAddition messages type MsgConsumerAdditionResponse struct { } @@ -1153,6 +1162,8 @@ type MsgConsumerModification struct { MinStake uint64 `protobuf:"varint,10,opt,name=min_stake,json=minStake,proto3" json:"min_stake,omitempty"` // Corresponds to the maximal rank in the provider chain validator set that a validator can have to validate on the consumer chain. MaxRank uint32 `protobuf:"varint,11,opt,name=max_rank,json=maxRank,proto3" json:"max_rank,omitempty"` + // Corresponds to whether inactive validators are allowed to validate the consumer chain. + AllowInactiveVals bool `protobuf:"varint,12,opt,name=allow_inactive_vals,json=allowInactiveVals,proto3" json:"allow_inactive_vals,omitempty"` } func (m *MsgConsumerModification) Reset() { *m = MsgConsumerModification{} } @@ -1265,6 +1276,13 @@ func (m *MsgConsumerModification) GetMaxRank() uint32 { return 0 } +func (m *MsgConsumerModification) GetAllowInactiveVals() bool { + if m != nil { + return m.AllowInactiveVals + } + return false +} + type MsgConsumerModificationResponse struct { } @@ -1331,116 +1349,118 @@ func init() { } var fileDescriptor_43221a4391e9fbf4 = []byte{ - // 1740 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x58, 0xcd, 0x8f, 0x1b, 0x49, - 0x15, 0x9f, 0xce, 0x7c, 0xc4, 0x7e, 0x9e, 0xcf, 0x9e, 0x09, 0xe3, 0x71, 0xb2, 0xf6, 0xc4, 0x2c, - 0xbb, 0xa3, 0xb0, 0xd3, 0xbd, 0x09, 0x6c, 0x16, 0x46, 0x8b, 0x60, 0x3e, 0x16, 0x92, 0xc0, 0x24, - 0x43, 0x27, 0x2c, 0x12, 0x48, 0xb4, 0xca, 0xdd, 0x95, 0x76, 0x69, 0xdc, 0x55, 0xad, 0xaa, 0xb2, - 0x13, 0xdf, 0xd0, 0x9e, 0x40, 0x48, 0x68, 0xb9, 0x21, 0x4e, 0x7b, 0x40, 0x08, 0x24, 0x90, 0x72, - 0xd8, 0x13, 0x37, 0x0e, 0x48, 0x39, 0x70, 0x58, 0xad, 0x38, 0x20, 0x0e, 0x01, 0x25, 0x87, 0xe5, - 0xcc, 0x5f, 0x80, 0xaa, 0xba, 0xba, 0xdd, 0x9e, 0x0f, 0xaf, 0x67, 0x02, 0x07, 0x2e, 0x96, 0xab, - 0xde, 0xef, 0xfd, 0xde, 0xfb, 0xbd, 0xea, 0x7a, 0x55, 0xdd, 0xf0, 0x06, 0xa1, 0x12, 0xf3, 0xa0, - 0x8d, 0x08, 0xf5, 0x05, 0x0e, 0xba, 0x9c, 0xc8, 0xbe, 0x1b, 0x04, 0x3d, 0x37, 0xe1, 0xac, 0x47, - 0x42, 0xcc, 0xdd, 0xde, 0x75, 0x57, 0x3e, 0x76, 0x12, 0xce, 0x24, 0xb3, 0x3f, 0x7f, 0x02, 0xda, - 0x09, 0x82, 0x9e, 0x93, 0xa1, 0x9d, 0xde, 0xf5, 0xda, 0x12, 0x8a, 0x09, 0x65, 0xae, 0xfe, 0x4d, - 0xfd, 0x6a, 0x57, 0x22, 0xc6, 0xa2, 0x0e, 0x76, 0x51, 0x42, 0x5c, 0x44, 0x29, 0x93, 0x48, 0x12, - 0x46, 0x85, 0xb1, 0x36, 0x8c, 0x55, 0x8f, 0x5a, 0xdd, 0x87, 0xae, 0x24, 0x31, 0x16, 0x12, 0xc5, - 0x89, 0x01, 0xd4, 0x8f, 0x02, 0xc2, 0x2e, 0xd7, 0x0c, 0xc6, 0xbe, 0x76, 0xd4, 0x8e, 0x68, 0xdf, - 0x98, 0x56, 0x22, 0x16, 0x31, 0xfd, 0xd7, 0x55, 0xff, 0x32, 0x87, 0x80, 0x89, 0x98, 0x09, 0x3f, - 0x35, 0xa4, 0x03, 0x63, 0x5a, 0x4d, 0x47, 0x6e, 0x2c, 0x22, 0x25, 0x3d, 0x16, 0x51, 0x96, 0x25, - 0x69, 0x05, 0x6e, 0xc0, 0x38, 0x76, 0x83, 0x0e, 0xc1, 0x54, 0x2a, 0x6b, 0xfa, 0xcf, 0x00, 0x6e, - 0x8c, 0x53, 0xca, 0xbc, 0x50, 0xa9, 0x8f, 0xab, 0x48, 0x3b, 0x24, 0x6a, 0xcb, 0x94, 0x4a, 0xb8, - 0x12, 0xd3, 0x10, 0xf3, 0x98, 0xa4, 0x01, 0x06, 0xa3, 0x2c, 0x8b, 0x82, 0x5d, 0xf6, 0x13, 0x2c, - 0x5c, 0xac, 0xf8, 0x68, 0x80, 0x53, 0x40, 0xf3, 0xaf, 0x16, 0xac, 0xec, 0x8b, 0x68, 0x5b, 0x08, - 0x12, 0xd1, 0x5d, 0x46, 0x45, 0x37, 0xc6, 0xfc, 0xdb, 0xb8, 0x6f, 0xaf, 0x41, 0x29, 0xcd, 0x8d, - 0x84, 0x55, 0x6b, 0xdd, 0xda, 0x28, 0x7b, 0x17, 0xf5, 0xf8, 0x76, 0x68, 0xbf, 0x0d, 0x73, 0x59, - 0x5e, 0x3e, 0x0a, 0x43, 0x5e, 0xbd, 0xa0, 0xec, 0x3b, 0xf6, 0xbf, 0x9f, 0x35, 0xe6, 0xfb, 0x28, - 0xee, 0x6c, 0x35, 0xd5, 0x2c, 0x16, 0xa2, 0xe9, 0xcd, 0x66, 0xc0, 0xed, 0x30, 0xe4, 0xf6, 0x55, - 0x98, 0x0d, 0x4c, 0x08, 0xff, 0x10, 0xf7, 0xab, 0x93, 0x9a, 0xb7, 0x12, 0x14, 0xc2, 0xbe, 0x09, - 0x33, 0x2a, 0x13, 0xcc, 0xab, 0x53, 0x9a, 0xb4, 0xfa, 0xc9, 0x47, 0x9b, 0x2b, 0xa6, 0xe2, 0xdb, - 0x29, 0xeb, 0x7d, 0xc9, 0x09, 0x8d, 0x3c, 0x83, 0xdb, 0x5a, 0xfe, 0xc9, 0x87, 0x8d, 0x89, 0x7f, - 0x7d, 0xd8, 0x98, 0x78, 0xff, 0xd3, 0x27, 0xd7, 0xcc, 0x64, 0xb3, 0x0e, 0x57, 0x4e, 0x52, 0xe5, - 0x61, 0x91, 0x30, 0x2a, 0x70, 0xf3, 0x4f, 0x16, 0xbc, 0xb2, 0x2f, 0xa2, 0xfb, 0xdd, 0x56, 0x4c, - 0x64, 0x06, 0xd8, 0x27, 0xa2, 0x85, 0xdb, 0xa8, 0x47, 0x58, 0x97, 0xdb, 0x37, 0xa1, 0x2c, 0xb4, - 0x55, 0x62, 0x9e, 0x16, 0x60, 0x44, 0x2e, 0x03, 0xa8, 0x7d, 0x00, 0xb3, 0x71, 0x81, 0x47, 0xd7, - 0xa6, 0x72, 0xe3, 0x0d, 0x87, 0xb4, 0x02, 0xa7, 0xb8, 0x72, 0x4e, 0x61, 0xad, 0x7a, 0xd7, 0x9d, - 0x62, 0x6c, 0x6f, 0x88, 0x61, 0xeb, 0x73, 0x45, 0x81, 0x83, 0x48, 0xcd, 0xd7, 0xe1, 0x0b, 0x23, - 0x25, 0xe4, 0x62, 0x9f, 0x5c, 0x38, 0x41, 0xec, 0x1e, 0xeb, 0xb6, 0x3a, 0xf8, 0x3d, 0x26, 0x09, - 0x8d, 0xce, 0x2d, 0xd6, 0x87, 0xd5, 0xb0, 0x9b, 0x74, 0x48, 0x80, 0x24, 0xf6, 0x7b, 0x4c, 0x62, - 0x3f, 0x7b, 0xbc, 0x8c, 0xee, 0xd7, 0x8b, 0x32, 0xf5, 0x03, 0xe8, 0xec, 0x65, 0x0e, 0xef, 0x31, - 0x89, 0xdf, 0x35, 0x70, 0xef, 0x52, 0x78, 0xd2, 0xb4, 0xfd, 0x23, 0x58, 0x25, 0xf4, 0x21, 0x47, - 0x81, 0xda, 0xbe, 0x7e, 0xab, 0xc3, 0x82, 0x43, 0xbf, 0x8d, 0x51, 0x88, 0xb9, 0x7e, 0x78, 0x2a, - 0x37, 0x5e, 0xfb, 0xac, 0xc2, 0xde, 0xd2, 0x68, 0xef, 0xd2, 0x80, 0x66, 0x47, 0xb1, 0xa4, 0xd3, - 0x67, 0xaa, 0x6d, 0xb1, 0x62, 0x79, 0x6d, 0x7f, 0x6d, 0xc1, 0xc2, 0xbe, 0x88, 0xbe, 0x97, 0x84, - 0x48, 0xe2, 0x03, 0xc4, 0x51, 0x2c, 0x54, 0x35, 0x51, 0x57, 0xb6, 0x99, 0xda, 0xd1, 0x9f, 0x5d, - 0xcd, 0x1c, 0x6a, 0xdf, 0x86, 0x99, 0x44, 0x33, 0x98, 0xe2, 0x7d, 0xd1, 0x19, 0xa3, 0x7f, 0x3a, - 0x69, 0xd0, 0x9d, 0xa9, 0xa7, 0xcf, 0x1a, 0x13, 0x9e, 0x21, 0xd8, 0x9a, 0xd7, 0x7a, 0x72, 0xea, - 0xe6, 0x1a, 0xac, 0x1e, 0xc9, 0x32, 0x57, 0xf0, 0xe7, 0x12, 0x2c, 0xef, 0x8b, 0x28, 0x53, 0xb9, - 0x1d, 0x86, 0x44, 0x55, 0x69, 0x54, 0x03, 0xf8, 0x16, 0xcc, 0x13, 0x4a, 0x24, 0x41, 0x1d, 0xbf, - 0x8d, 0x55, 0xe9, 0x4d, 0xc2, 0x35, 0xbd, 0x18, 0xaa, 0xe9, 0x39, 0xa6, 0xd5, 0xe9, 0x05, 0x50, - 0x08, 0x93, 0xdf, 0x9c, 0xf1, 0x4b, 0x27, 0x55, 0x43, 0x88, 0x30, 0xc5, 0x82, 0x08, 0xbf, 0x8d, - 0x44, 0x5b, 0xaf, 0xe9, 0xac, 0x57, 0x31, 0x73, 0xb7, 0x90, 0x68, 0xdb, 0x0d, 0xa8, 0xb4, 0x08, - 0x45, 0xbc, 0x9f, 0x22, 0xa6, 0x34, 0x02, 0xd2, 0x29, 0x0d, 0xd8, 0x05, 0x10, 0x09, 0x7a, 0x44, - 0x7d, 0x75, 0x0c, 0x54, 0xa7, 0x4d, 0x22, 0x69, 0x8b, 0x77, 0xb2, 0x16, 0xef, 0x3c, 0xc8, 0xce, - 0x88, 0x9d, 0x92, 0x4a, 0xe4, 0x83, 0x7f, 0x34, 0x2c, 0xaf, 0xac, 0xfd, 0x94, 0xc5, 0xbe, 0x0b, - 0x8b, 0x5d, 0xda, 0x62, 0x34, 0x24, 0x34, 0xf2, 0x13, 0xcc, 0x09, 0x0b, 0xab, 0x33, 0x9a, 0x6a, - 0xed, 0x18, 0xd5, 0x9e, 0x39, 0x4d, 0x52, 0xa6, 0x5f, 0x2a, 0xa6, 0x85, 0xdc, 0xf9, 0x40, 0xfb, - 0xda, 0xdf, 0x05, 0x3b, 0x08, 0x7a, 0x3a, 0x25, 0xd6, 0x95, 0x19, 0xe3, 0xc5, 0xf1, 0x19, 0x17, - 0x83, 0xa0, 0xf7, 0x20, 0xf5, 0x36, 0x94, 0x3f, 0x84, 0x55, 0xc9, 0x11, 0x15, 0x0f, 0x31, 0x3f, - 0xca, 0x5b, 0x1a, 0x9f, 0xf7, 0x52, 0xc6, 0x31, 0x4c, 0x7e, 0x0b, 0xd6, 0xf3, 0xce, 0xcc, 0x71, - 0x48, 0x84, 0xe4, 0xa4, 0xd5, 0xd5, 0x9b, 0x2e, 0xdb, 0x36, 0xd5, 0xb2, 0x7e, 0x08, 0xea, 0x19, - 0xce, 0x1b, 0x82, 0x7d, 0xd3, 0xa0, 0xec, 0x7b, 0xf0, 0xaa, 0xde, 0xa6, 0x42, 0x25, 0xe7, 0x0f, - 0x31, 0xe9, 0xd0, 0x31, 0x11, 0x42, 0xb1, 0xc1, 0xba, 0xb5, 0x31, 0xe9, 0x5d, 0x4d, 0xb1, 0x07, - 0x98, 0xef, 0x15, 0x90, 0x0f, 0x0a, 0x40, 0x7b, 0x13, 0xec, 0x36, 0x11, 0x92, 0x71, 0x12, 0xa0, - 0x8e, 0x8f, 0xa9, 0xe4, 0x04, 0x8b, 0x6a, 0x45, 0xbb, 0x2f, 0x0d, 0x2c, 0xef, 0xa6, 0x06, 0xfb, - 0x0e, 0x5c, 0x3d, 0x35, 0xa8, 0x1f, 0xb4, 0x11, 0xa5, 0xb8, 0x53, 0x9d, 0xd5, 0x52, 0x1a, 0xe1, - 0x29, 0x31, 0x77, 0x53, 0x98, 0xbd, 0x0c, 0xd3, 0x92, 0x25, 0xfe, 0xdd, 0xea, 0xdc, 0xba, 0xb5, - 0x31, 0xe7, 0x4d, 0x49, 0x96, 0xdc, 0xb5, 0xdf, 0x84, 0x95, 0x1e, 0xea, 0x90, 0x10, 0x49, 0xc6, - 0x85, 0x9f, 0xb0, 0x47, 0x98, 0xfb, 0x01, 0x4a, 0xaa, 0xf3, 0x1a, 0x63, 0x0f, 0x6c, 0x07, 0xca, - 0xb4, 0x8b, 0x12, 0xfb, 0x1a, 0x2c, 0xe5, 0xb3, 0xbe, 0xc0, 0x52, 0xc3, 0x17, 0x34, 0x7c, 0x21, - 0x37, 0xdc, 0xc7, 0x52, 0x61, 0xaf, 0x40, 0x19, 0x75, 0x3a, 0xec, 0x51, 0x87, 0x08, 0x59, 0x5d, - 0x5c, 0x9f, 0xdc, 0x28, 0x7b, 0x83, 0x09, 0xbb, 0x06, 0xa5, 0x10, 0xd3, 0xbe, 0x36, 0x2e, 0x69, - 0x63, 0x3e, 0x1e, 0xee, 0x3a, 0xf6, 0xf8, 0x5d, 0xe7, 0x32, 0x94, 0x63, 0xd5, 0x5f, 0x24, 0x3a, - 0xc4, 0xd5, 0xe5, 0x75, 0x6b, 0x63, 0xca, 0x2b, 0xc5, 0x84, 0xde, 0x57, 0x63, 0xd5, 0x04, 0x62, - 0xf4, 0xd8, 0xe7, 0x88, 0x1e, 0x56, 0x57, 0x74, 0xc6, 0x17, 0x63, 0xf4, 0xd8, 0x43, 0xf4, 0xf0, - 0x58, 0x8b, 0x79, 0x05, 0x2e, 0x9f, 0xd0, 0x46, 0xf2, 0x36, 0xf3, 0x47, 0x0b, 0xec, 0x82, 0xdd, - 0xc3, 0x31, 0xeb, 0xa1, 0xce, 0xa8, 0x2e, 0xb3, 0x0d, 0x65, 0xa1, 0xca, 0xaf, 0xf7, 0xf5, 0x85, - 0x33, 0xec, 0xeb, 0x92, 0x72, 0xd3, 0xdb, 0x7a, 0xa8, 0x26, 0x93, 0x63, 0xd7, 0xe4, 0x98, 0xb6, - 0x2b, 0x50, 0x3b, 0x9e, 0x7b, 0x2e, 0xed, 0x0f, 0x16, 0x5c, 0x52, 0xe6, 0x36, 0xa2, 0x11, 0xf6, - 0xf0, 0x23, 0xc4, 0xc3, 0x3d, 0x4c, 0x59, 0x2c, 0xec, 0x26, 0xcc, 0x85, 0xfa, 0x9f, 0x2f, 0x99, - 0xba, 0x2a, 0x55, 0x2d, 0xbd, 0x68, 0x95, 0x74, 0xf2, 0x01, 0xdb, 0x0e, 0x43, 0x7b, 0x03, 0x16, - 0x07, 0x18, 0xae, 0xa8, 0x95, 0x5a, 0x05, 0x9b, 0xcf, 0x60, 0x3a, 0xe0, 0x7f, 0x4f, 0x4d, 0x43, - 0x5f, 0x07, 0x8e, 0xa7, 0x9b, 0x0b, 0x7a, 0x6a, 0x41, 0x69, 0x5f, 0x44, 0xf7, 0x12, 0x79, 0x9b, - 0xfe, 0x9f, 0x5f, 0x04, 0x6d, 0x58, 0xcc, 0x94, 0xe4, 0xf2, 0x7e, 0x63, 0x41, 0x39, 0x9d, 0xbc, - 0xd7, 0x95, 0xff, 0x13, 0x7d, 0x83, 0xe4, 0x27, 0x5f, 0x26, 0xf9, 0x65, 0x58, 0xca, 0xf3, 0x2c, - 0x2e, 0x8e, 0xba, 0xdb, 0xaa, 0x7e, 0x61, 0xca, 0xb5, 0xcb, 0x62, 0xd3, 0xb8, 0x3c, 0x24, 0xf1, - 0xf1, 0xac, 0xad, 0x31, 0xb3, 0x2e, 0x56, 0xe2, 0xc2, 0x70, 0x25, 0xee, 0xc0, 0x14, 0x47, 0x12, - 0x1b, 0x39, 0x37, 0xd5, 0x56, 0xfb, 0xfb, 0xb3, 0xc6, 0xe5, 0x54, 0x92, 0x08, 0x0f, 0x1d, 0xc2, - 0xdc, 0x18, 0xc9, 0xb6, 0xf3, 0x1d, 0x1c, 0xa1, 0xa0, 0xbf, 0x87, 0x83, 0x4f, 0x3e, 0xda, 0x04, - 0xa3, 0x78, 0x0f, 0x07, 0xbf, 0xfd, 0xf4, 0xc9, 0x35, 0xcb, 0xd3, 0x1c, 0x5b, 0xa5, 0x4c, 0x6a, - 0xf3, 0x35, 0x78, 0x75, 0x94, 0x92, 0x5c, 0xf2, 0x4f, 0x27, 0xf5, 0xf5, 0x25, 0xbf, 0xe4, 0xb2, - 0x90, 0x3c, 0x54, 0x77, 0x45, 0x75, 0x3c, 0xac, 0xc0, 0xb4, 0x24, 0xb2, 0x83, 0xcd, 0xda, 0xa5, - 0x03, 0x7b, 0x1d, 0x2a, 0x21, 0x16, 0x01, 0x27, 0x89, 0x3e, 0xba, 0x52, 0x35, 0xc5, 0xa9, 0x21, - 0xb1, 0x93, 0xc3, 0x62, 0xf3, 0xb6, 0x3f, 0x35, 0x46, 0xdb, 0x9f, 0x3e, 0x5b, 0xdb, 0x9f, 0x19, - 0xa3, 0xed, 0x5f, 0x1c, 0xd5, 0xf6, 0x4b, 0xa3, 0xda, 0x7e, 0xf9, 0x9c, 0x6d, 0x1f, 0x46, 0xb4, - 0xfd, 0xca, 0x50, 0xdb, 0x6f, 0x5e, 0x85, 0xc6, 0x29, 0x4b, 0x91, 0x2d, 0xd7, 0x8d, 0xbf, 0x54, - 0x60, 0x72, 0x5f, 0x44, 0xf6, 0x2f, 0x2c, 0x58, 0x3a, 0xfe, 0x62, 0xf9, 0xd5, 0xb1, 0x6e, 0xb5, - 0x27, 0xbd, 0xbd, 0xd5, 0xb6, 0xcf, 0xed, 0x9a, 0xe5, 0x66, 0xff, 0xde, 0x82, 0xda, 0x88, 0xb7, - 0xbe, 0x9d, 0x71, 0x23, 0x9c, 0xce, 0x51, 0xbb, 0xf3, 0xf2, 0x1c, 0x23, 0xd2, 0x1d, 0x7a, 0x6f, - 0x3b, 0x67, 0xba, 0x45, 0x8e, 0xf3, 0xa6, 0x7b, 0xd2, 0xdb, 0x90, 0xfd, 0x73, 0x0b, 0x16, 0x8f, - 0xbd, 0x48, 0x7c, 0x65, 0xdc, 0x00, 0x47, 0x3d, 0x6b, 0xdf, 0x38, 0xaf, 0x67, 0x9e, 0xd0, 0xcf, - 0x2c, 0x58, 0x38, 0x7a, 0xe5, 0x78, 0xfb, 0xac, 0xac, 0xc6, 0xb1, 0xf6, 0xf5, 0x73, 0x3a, 0xe6, - 0xd9, 0xbc, 0x6f, 0xc1, 0xec, 0xd0, 0x9b, 0xe2, 0x97, 0xc7, 0x65, 0x2c, 0x7a, 0xd5, 0xde, 0x39, - 0x8f, 0x57, 0x9e, 0x44, 0x0c, 0xd3, 0xe9, 0xc1, 0xbe, 0x39, 0x2e, 0x8d, 0x86, 0xd7, 0xde, 0x3a, - 0x13, 0x3c, 0x0f, 0x97, 0xc0, 0x8c, 0x39, 0x68, 0x9d, 0x33, 0x10, 0xdc, 0xeb, 0xca, 0xda, 0xcd, - 0xb3, 0xe1, 0xf3, 0x88, 0xbf, 0xb3, 0x60, 0xed, 0xf4, 0xd3, 0x71, 0xec, 0x1e, 0x72, 0x2a, 0x45, - 0xed, 0xf6, 0x4b, 0x53, 0xe4, 0xb9, 0xfe, 0xca, 0x82, 0x95, 0x13, 0x8f, 0xb5, 0x77, 0xce, 0xfa, - 0xac, 0x15, 0xbd, 0x6b, 0x7b, 0x2f, 0xe3, 0x9d, 0x25, 0x57, 0x9b, 0xfe, 0xb1, 0x3a, 0xb5, 0x77, - 0xbe, 0xff, 0xf4, 0x79, 0xdd, 0xfa, 0xf8, 0x79, 0xdd, 0xfa, 0xe7, 0xf3, 0xba, 0xf5, 0xc1, 0x8b, - 0xfa, 0xc4, 0xc7, 0x2f, 0xea, 0x13, 0x7f, 0x7b, 0x51, 0x9f, 0xf8, 0xc1, 0xd7, 0x22, 0x22, 0xdb, - 0xdd, 0x96, 0x13, 0xb0, 0xd8, 0x7c, 0x15, 0x75, 0x07, 0x71, 0x37, 0xf3, 0x8f, 0x9a, 0xbd, 0xb7, - 0xdc, 0xc7, 0xc3, 0x5f, 0x36, 0xf5, 0x97, 0xa0, 0xd6, 0x8c, 0xbe, 0xc5, 0x7f, 0xe9, 0x3f, 0x01, - 0x00, 0x00, 0xff, 0xff, 0x8c, 0x08, 0xac, 0xcb, 0x55, 0x16, 0x00, 0x00, + // 1771 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x58, 0x4d, 0x8c, 0xdc, 0x48, + 0x15, 0x1e, 0x67, 0x7e, 0xd2, 0x5d, 0x3d, 0xbf, 0x9e, 0x19, 0xc6, 0xd3, 0xc9, 0x76, 0x4f, 0x9a, + 0x65, 0x77, 0x14, 0x76, 0xec, 0x4d, 0x60, 0xb3, 0x30, 0x5a, 0x04, 0xf3, 0xb3, 0x90, 0x09, 0x4c, + 0x32, 0x38, 0x21, 0x48, 0x20, 0x61, 0x55, 0xdb, 0x15, 0x77, 0x69, 0xec, 0x2a, 0xab, 0xaa, 0xba, + 0x93, 0xbe, 0xa1, 0x3d, 0x21, 0x21, 0xa1, 0xe5, 0x86, 0x38, 0xed, 0x01, 0x21, 0x90, 0x40, 0xca, + 0x61, 0x2f, 0x70, 0xe3, 0x96, 0x03, 0x87, 0xd5, 0x8a, 0x03, 0xe2, 0x10, 0x50, 0x72, 0x58, 0xce, + 0x48, 0xdc, 0x51, 0x95, 0xcb, 0x6e, 0xf7, 0xfc, 0x74, 0x3c, 0x33, 0x70, 0xe0, 0xd2, 0x6a, 0xd7, + 0xfb, 0xde, 0xf7, 0xbe, 0xf7, 0xca, 0x7e, 0xaf, 0x6c, 0xf0, 0x16, 0x26, 0x02, 0x31, 0xbf, 0x03, + 0x31, 0xf1, 0x38, 0xf2, 0xbb, 0x0c, 0x8b, 0xbe, 0xe3, 0xfb, 0x3d, 0x27, 0x61, 0xb4, 0x87, 0x03, + 0xc4, 0x9c, 0xde, 0x0d, 0x47, 0x3c, 0xb1, 0x13, 0x46, 0x05, 0x35, 0x3f, 0x7f, 0x02, 0xda, 0xf6, + 0xfd, 0x9e, 0x9d, 0xa1, 0xed, 0xde, 0x8d, 0xfa, 0x02, 0x8c, 0x31, 0xa1, 0x8e, 0xfa, 0x4d, 0xfd, + 0xea, 0x57, 0x43, 0x4a, 0xc3, 0x08, 0x39, 0x30, 0xc1, 0x0e, 0x24, 0x84, 0x0a, 0x28, 0x30, 0x25, + 0x5c, 0x5b, 0x9b, 0xda, 0xaa, 0xae, 0xda, 0xdd, 0x47, 0x8e, 0xc0, 0x31, 0xe2, 0x02, 0xc6, 0x89, + 0x06, 0x34, 0x8e, 0x02, 0x82, 0x2e, 0x53, 0x0c, 0xda, 0xbe, 0x7a, 0xd4, 0x0e, 0x49, 0x5f, 0x9b, + 0x96, 0x42, 0x1a, 0x52, 0xf5, 0xd7, 0x91, 0xff, 0x32, 0x07, 0x9f, 0xf2, 0x98, 0x72, 0x2f, 0x35, + 0xa4, 0x17, 0xda, 0xb4, 0x92, 0x5e, 0x39, 0x31, 0x0f, 0x65, 0xea, 0x31, 0x0f, 0x33, 0x95, 0xb8, + 0xed, 0x3b, 0x3e, 0x65, 0xc8, 0xf1, 0x23, 0x8c, 0x88, 0x90, 0xd6, 0xf4, 0x9f, 0x06, 0xdc, 0x2c, + 0x53, 0xca, 0xbc, 0x50, 0xa9, 0x8f, 0x23, 0x49, 0x23, 0x1c, 0x76, 0x44, 0x4a, 0xc5, 0x1d, 0x81, + 0x48, 0x80, 0x58, 0x8c, 0xd3, 0x00, 0x83, 0xab, 0x4c, 0x45, 0xc1, 0x2e, 0xfa, 0x09, 0xe2, 0x0e, + 0x92, 0x7c, 0xc4, 0x47, 0x29, 0xa0, 0xf5, 0x17, 0x03, 0x2c, 0xed, 0xf3, 0x70, 0x8b, 0x73, 0x1c, + 0x92, 0x1d, 0x4a, 0x78, 0x37, 0x46, 0xec, 0xdb, 0xa8, 0x6f, 0xae, 0x82, 0x4a, 0xaa, 0x0d, 0x07, + 0x96, 0xb1, 0x66, 0xac, 0x57, 0xdd, 0xcb, 0xea, 0x7a, 0x2f, 0x30, 0xdf, 0x05, 0x33, 0x99, 0x2e, + 0x0f, 0x06, 0x01, 0xb3, 0x2e, 0x49, 0xfb, 0xb6, 0xf9, 0xaf, 0xe7, 0xcd, 0xd9, 0x3e, 0x8c, 0xa3, + 0xcd, 0x96, 0x5c, 0x45, 0x9c, 0xb7, 0xdc, 0xe9, 0x0c, 0xb8, 0x15, 0x04, 0xcc, 0xbc, 0x06, 0xa6, + 0x7d, 0x1d, 0xc2, 0x3b, 0x44, 0x7d, 0x6b, 0x5c, 0xf1, 0xd6, 0xfc, 0x42, 0xd8, 0xb7, 0xc1, 0x94, + 0x54, 0x82, 0x98, 0x35, 0xa1, 0x48, 0xad, 0x4f, 0x3f, 0xde, 0x58, 0xd2, 0x15, 0xdf, 0x4a, 0x59, + 0xef, 0x0b, 0x86, 0x49, 0xe8, 0x6a, 0xdc, 0xe6, 0xe2, 0x4f, 0x3e, 0x6a, 0x8e, 0xfd, 0xf3, 0xa3, + 0xe6, 0xd8, 0x07, 0x9f, 0x3d, 0xbd, 0xae, 0x17, 0x5b, 0x0d, 0x70, 0xf5, 0xa4, 0xac, 0x5c, 0xc4, + 0x13, 0x4a, 0x38, 0x6a, 0xfd, 0xc9, 0x00, 0xaf, 0xed, 0xf3, 0xf0, 0x7e, 0xb7, 0x1d, 0x63, 0x91, + 0x01, 0xf6, 0x31, 0x6f, 0xa3, 0x0e, 0xec, 0x61, 0xda, 0x65, 0xe6, 0x2d, 0x50, 0xe5, 0xca, 0x2a, + 0x10, 0x4b, 0x0b, 0x30, 0x42, 0xcb, 0x00, 0x6a, 0x1e, 0x80, 0xe9, 0xb8, 0xc0, 0xa3, 0x6a, 0x53, + 0xbb, 0xf9, 0x96, 0x8d, 0xdb, 0xbe, 0x5d, 0xdc, 0x39, 0xbb, 0xb0, 0x57, 0xbd, 0x1b, 0x76, 0x31, + 0xb6, 0x3b, 0xc4, 0xb0, 0xf9, 0xb9, 0x62, 0x82, 0x83, 0x48, 0xad, 0x37, 0xc1, 0x17, 0x46, 0xa6, + 0x90, 0x27, 0xfb, 0xf4, 0xd2, 0x09, 0xc9, 0xee, 0xd2, 0x6e, 0x3b, 0x42, 0x0f, 0xa9, 0xc0, 0x24, + 0x3c, 0x77, 0xb2, 0x1e, 0x58, 0x09, 0xba, 0x49, 0x84, 0x7d, 0x28, 0x90, 0xd7, 0xa3, 0x02, 0x79, + 0xd9, 0xed, 0xa5, 0xf3, 0x7e, 0xb3, 0x98, 0xa6, 0xba, 0x01, 0xed, 0xdd, 0xcc, 0xe1, 0x21, 0x15, + 0xe8, 0x7d, 0x0d, 0x77, 0x97, 0x83, 0x93, 0x96, 0xcd, 0x1f, 0x81, 0x15, 0x4c, 0x1e, 0x31, 0xe8, + 0xcb, 0xc7, 0xd7, 0x6b, 0x47, 0xd4, 0x3f, 0xf4, 0x3a, 0x08, 0x06, 0x88, 0xa9, 0x9b, 0xa7, 0x76, + 0xf3, 0x8d, 0x57, 0x15, 0xf6, 0xb6, 0x42, 0xbb, 0xcb, 0x03, 0x9a, 0x6d, 0xc9, 0x92, 0x2e, 0x9f, + 0xa9, 0xb6, 0xc5, 0x8a, 0xe5, 0xb5, 0xfd, 0x95, 0x01, 0xe6, 0xf6, 0x79, 0xf8, 0xbd, 0x24, 0x80, + 0x02, 0x1d, 0x40, 0x06, 0x63, 0x2e, 0xab, 0x09, 0xbb, 0xa2, 0x43, 0xe5, 0x13, 0xfd, 0xea, 0x6a, + 0xe6, 0x50, 0x73, 0x0f, 0x4c, 0x25, 0x8a, 0x41, 0x17, 0xef, 0x8b, 0x76, 0x89, 0xfe, 0x69, 0xa7, + 0x41, 0xb7, 0x27, 0x9e, 0x3d, 0x6f, 0x8e, 0xb9, 0x9a, 0x60, 0x73, 0x56, 0xe5, 0x93, 0x53, 0xb7, + 0x56, 0xc1, 0xca, 0x11, 0x95, 0x79, 0x06, 0xff, 0xae, 0x80, 0xc5, 0x7d, 0x1e, 0x66, 0x59, 0x6e, + 0x05, 0x01, 0x96, 0x55, 0x1a, 0xd5, 0x00, 0xbe, 0x05, 0x66, 0x31, 0xc1, 0x02, 0xc3, 0xc8, 0xeb, + 0x20, 0x59, 0x7a, 0x2d, 0xb8, 0xae, 0x36, 0x43, 0x36, 0x3d, 0x5b, 0xb7, 0x3a, 0xb5, 0x01, 0x12, + 0xa1, 0xf5, 0xcd, 0x68, 0xbf, 0x74, 0x51, 0x36, 0x84, 0x10, 0x11, 0xc4, 0x31, 0xf7, 0x3a, 0x90, + 0x77, 0xd4, 0x9e, 0x4e, 0xbb, 0x35, 0xbd, 0x76, 0x1b, 0xf2, 0x8e, 0xd9, 0x04, 0xb5, 0x36, 0x26, + 0x90, 0xf5, 0x53, 0xc4, 0x84, 0x42, 0x80, 0x74, 0x49, 0x01, 0x76, 0x00, 0xe0, 0x09, 0x7c, 0x4c, + 0x3c, 0x39, 0x06, 0xac, 0x49, 0x2d, 0x24, 0x6d, 0xf1, 0x76, 0xd6, 0xe2, 0xed, 0x07, 0xd9, 0x8c, + 0xd8, 0xae, 0x48, 0x21, 0x1f, 0xfe, 0xbd, 0x69, 0xb8, 0x55, 0xe5, 0x27, 0x2d, 0xe6, 0x5d, 0x30, + 0xdf, 0x25, 0x6d, 0x4a, 0x02, 0x4c, 0x42, 0x2f, 0x41, 0x0c, 0xd3, 0xc0, 0x9a, 0x52, 0x54, 0xab, + 0xc7, 0xa8, 0x76, 0xf5, 0x34, 0x49, 0x99, 0x7e, 0x21, 0x99, 0xe6, 0x72, 0xe7, 0x03, 0xe5, 0x6b, + 0x7e, 0x17, 0x98, 0xbe, 0xdf, 0x53, 0x92, 0x68, 0x57, 0x64, 0x8c, 0x97, 0xcb, 0x33, 0xce, 0xfb, + 0x7e, 0xef, 0x41, 0xea, 0xad, 0x29, 0x7f, 0x08, 0x56, 0x04, 0x83, 0x84, 0x3f, 0x42, 0xec, 0x28, + 0x6f, 0xa5, 0x3c, 0xef, 0x72, 0xc6, 0x31, 0x4c, 0x7e, 0x1b, 0xac, 0xe5, 0x9d, 0x99, 0xa1, 0x00, + 0x73, 0xc1, 0x70, 0xbb, 0xab, 0x1e, 0xba, 0xec, 0xb1, 0xb1, 0xaa, 0xea, 0x26, 0x68, 0x64, 0x38, + 0x77, 0x08, 0xf6, 0x4d, 0x8d, 0x32, 0xef, 0x81, 0xd7, 0xd5, 0x63, 0xca, 0xa5, 0x38, 0x6f, 0x88, + 0x49, 0x85, 0x8e, 0x31, 0xe7, 0x92, 0x0d, 0xac, 0x19, 0xeb, 0xe3, 0xee, 0xb5, 0x14, 0x7b, 0x80, + 0xd8, 0x6e, 0x01, 0xf9, 0xa0, 0x00, 0x34, 0x37, 0x80, 0xd9, 0xc1, 0x5c, 0x50, 0x86, 0x7d, 0x18, + 0x79, 0x88, 0x08, 0x86, 0x11, 0xb7, 0x6a, 0xca, 0x7d, 0x61, 0x60, 0x79, 0x3f, 0x35, 0x98, 0x77, + 0xc0, 0xb5, 0x53, 0x83, 0x7a, 0x7e, 0x07, 0x12, 0x82, 0x22, 0x6b, 0x5a, 0xa5, 0xd2, 0x0c, 0x4e, + 0x89, 0xb9, 0x93, 0xc2, 0xcc, 0x45, 0x30, 0x29, 0x68, 0xe2, 0xdd, 0xb5, 0x66, 0xd6, 0x8c, 0xf5, + 0x19, 0x77, 0x42, 0xd0, 0xe4, 0xae, 0xf9, 0x36, 0x58, 0xea, 0xc1, 0x08, 0x07, 0x50, 0x50, 0xc6, + 0xbd, 0x84, 0x3e, 0x46, 0xcc, 0xf3, 0x61, 0x62, 0xcd, 0x2a, 0x8c, 0x39, 0xb0, 0x1d, 0x48, 0xd3, + 0x0e, 0x4c, 0xcc, 0xeb, 0x60, 0x21, 0x5f, 0xf5, 0x38, 0x12, 0x0a, 0x3e, 0xa7, 0xe0, 0x73, 0xb9, + 0xe1, 0x3e, 0x12, 0x12, 0x7b, 0x15, 0x54, 0x61, 0x14, 0xd1, 0xc7, 0x11, 0xe6, 0xc2, 0x9a, 0x5f, + 0x1b, 0x5f, 0xaf, 0xba, 0x83, 0x05, 0xb3, 0x0e, 0x2a, 0x01, 0x22, 0x7d, 0x65, 0x5c, 0x50, 0xc6, + 0xfc, 0x7a, 0xb8, 0xeb, 0x98, 0xe5, 0xbb, 0xce, 0x15, 0x50, 0x8d, 0x65, 0x7f, 0x11, 0xf0, 0x10, + 0x59, 0x8b, 0x6b, 0xc6, 0xfa, 0x84, 0x5b, 0x89, 0x31, 0xb9, 0x2f, 0xaf, 0x65, 0x13, 0x88, 0xe1, + 0x13, 0x8f, 0x41, 0x72, 0x68, 0x2d, 0x29, 0xc5, 0x97, 0x63, 0xf8, 0xc4, 0x85, 0xe4, 0xd0, 0xb4, + 0xc1, 0xa2, 0x12, 0xe6, 0x61, 0x22, 0xb7, 0xbe, 0x87, 0xbc, 0x1e, 0x8c, 0xb8, 0xb5, 0xbc, 0x66, + 0xac, 0x57, 0xdc, 0x05, 0x65, 0xda, 0xd3, 0x96, 0x87, 0x30, 0x3a, 0xde, 0x92, 0x5e, 0x03, 0x57, + 0x4e, 0x68, 0x3b, 0x79, 0x5b, 0xfa, 0xa3, 0x01, 0xcc, 0x82, 0xdd, 0x45, 0x31, 0xed, 0xc1, 0x68, + 0x54, 0x57, 0xda, 0x02, 0x55, 0x2e, 0xb7, 0x4b, 0xf5, 0x81, 0x4b, 0x67, 0xe8, 0x03, 0x15, 0xe9, + 0xa6, 0xda, 0xc0, 0x50, 0x0d, 0xc7, 0x4b, 0xd7, 0xf0, 0x58, 0x6e, 0x57, 0x41, 0xfd, 0xb8, 0xf6, + 0x3c, 0xb5, 0xdf, 0x1b, 0x60, 0x59, 0x9a, 0x3b, 0x90, 0x84, 0xc8, 0x45, 0x8f, 0x21, 0x0b, 0x76, + 0x11, 0xa1, 0x31, 0x37, 0x5b, 0x60, 0x26, 0x50, 0xff, 0x3c, 0x41, 0xe5, 0xd1, 0xca, 0x32, 0xd4, + 0x26, 0xd7, 0xd2, 0xc5, 0x07, 0x74, 0x2b, 0x08, 0xcc, 0x75, 0x30, 0x3f, 0xc0, 0x30, 0x49, 0x2d, + 0xb3, 0x95, 0xb0, 0xd9, 0x0c, 0xa6, 0x02, 0xfe, 0xf7, 0xb2, 0x69, 0xaa, 0xe3, 0xc3, 0x71, 0xb9, + 0x79, 0x42, 0xcf, 0x0c, 0x50, 0xd9, 0xe7, 0xe1, 0xbd, 0x44, 0xec, 0x91, 0xff, 0xf3, 0x83, 0xa3, + 0x09, 0xe6, 0xb3, 0x4c, 0xf2, 0xf4, 0x7e, 0x6d, 0x80, 0x6a, 0xba, 0x78, 0xaf, 0x2b, 0xfe, 0x27, + 0xf9, 0x0d, 0xc4, 0x8f, 0x5f, 0x44, 0xfc, 0x22, 0x58, 0xc8, 0x75, 0x16, 0x37, 0x47, 0x9e, 0x85, + 0x65, 0x7f, 0xd1, 0xe5, 0xda, 0xa1, 0xb1, 0x6e, 0x74, 0x2e, 0x14, 0xe8, 0xb8, 0x6a, 0xa3, 0xa4, + 0xea, 0x62, 0x25, 0x2e, 0x0d, 0x57, 0xe2, 0x0e, 0x98, 0x60, 0x50, 0x20, 0x9d, 0xce, 0x2d, 0xf9, + 0xa8, 0xfd, 0xed, 0x79, 0xf3, 0x4a, 0x9a, 0x12, 0x0f, 0x0e, 0x6d, 0x4c, 0x9d, 0x18, 0x8a, 0x8e, + 0xfd, 0x1d, 0x14, 0x42, 0xbf, 0xbf, 0x8b, 0xfc, 0x4f, 0x3f, 0xde, 0x00, 0x3a, 0xe3, 0x5d, 0xe4, + 0xff, 0xe6, 0xb3, 0xa7, 0xd7, 0x0d, 0x57, 0x71, 0x6c, 0x56, 0xb2, 0x54, 0x5b, 0x6f, 0x80, 0xd7, + 0x47, 0x65, 0x92, 0xa7, 0xfc, 0x87, 0x71, 0x75, 0xdc, 0xc9, 0x0f, 0xc5, 0x34, 0xc0, 0x8f, 0xe4, + 0xd9, 0x52, 0x8e, 0x93, 0x25, 0x30, 0x29, 0xb0, 0x88, 0x90, 0xde, 0xbb, 0xf4, 0xc2, 0x5c, 0x03, + 0xb5, 0x00, 0x71, 0x9f, 0xe1, 0x44, 0x8d, 0xba, 0x34, 0x9b, 0xe2, 0xd2, 0x50, 0xb2, 0xe3, 0xc3, + 0xc9, 0xe6, 0x63, 0x62, 0xa2, 0xc4, 0x98, 0x98, 0x3c, 0xdb, 0x98, 0x98, 0x2a, 0x31, 0x26, 0x2e, + 0x8f, 0x1a, 0x13, 0x95, 0x51, 0x63, 0xa2, 0x7a, 0xce, 0x31, 0x01, 0x46, 0x8c, 0x89, 0x5a, 0xa9, + 0x31, 0x31, 0x7d, 0xca, 0x98, 0x68, 0x5d, 0x03, 0xcd, 0x53, 0xb6, 0x2e, 0xdb, 0xde, 0x9b, 0x7f, + 0xae, 0x81, 0xf1, 0x7d, 0x1e, 0x9a, 0x3f, 0x37, 0xc0, 0xc2, 0xf1, 0x17, 0xd7, 0xaf, 0x96, 0x3a, + 0x35, 0x9f, 0xf4, 0x76, 0x58, 0xdf, 0x3a, 0xb7, 0x6b, 0xa6, 0xcd, 0xfc, 0x9d, 0x01, 0xea, 0x23, + 0xde, 0x2a, 0xb7, 0xcb, 0x46, 0x38, 0x9d, 0xa3, 0x7e, 0xe7, 0xe2, 0x1c, 0x23, 0xe4, 0x0e, 0xbd, + 0x17, 0x9e, 0x53, 0x6e, 0x91, 0xe3, 0xbc, 0x72, 0x4f, 0x7a, 0xdb, 0x32, 0x7f, 0x66, 0x80, 0xf9, + 0x63, 0x2f, 0x2a, 0x5f, 0x29, 0x1b, 0xe0, 0xa8, 0x67, 0xfd, 0x1b, 0xe7, 0xf5, 0xcc, 0x05, 0xfd, + 0xd4, 0x00, 0x73, 0x47, 0x8f, 0x28, 0xef, 0x9e, 0x95, 0x55, 0x3b, 0xd6, 0xbf, 0x7e, 0x4e, 0xc7, + 0x5c, 0xcd, 0x07, 0x06, 0x98, 0x1e, 0x7a, 0x13, 0xfd, 0x72, 0x59, 0xc6, 0xa2, 0x57, 0xfd, 0xbd, + 0xf3, 0x78, 0xe5, 0x22, 0x62, 0x30, 0x99, 0x1e, 0x04, 0x36, 0xca, 0xd2, 0x28, 0x78, 0xfd, 0x9d, + 0x33, 0xc1, 0xf3, 0x70, 0x09, 0x98, 0xd2, 0x83, 0xd9, 0x3e, 0x03, 0xc1, 0xbd, 0xae, 0xa8, 0xdf, + 0x3a, 0x1b, 0x3e, 0x8f, 0xf8, 0x5b, 0x03, 0xac, 0x9e, 0x3e, 0x4d, 0x4b, 0xf7, 0x90, 0x53, 0x29, + 0xea, 0x7b, 0x17, 0xa6, 0xc8, 0xb5, 0xfe, 0xd2, 0x00, 0x4b, 0x27, 0x8e, 0xc1, 0xf7, 0xce, 0x7a, + 0xaf, 0x15, 0xbd, 0xeb, 0xbb, 0x17, 0xf1, 0xce, 0xc4, 0xd5, 0x27, 0x7f, 0x2c, 0xa7, 0xfc, 0xf6, + 0xf7, 0x9f, 0xbd, 0x68, 0x18, 0x9f, 0xbc, 0x68, 0x18, 0xff, 0x78, 0xd1, 0x30, 0x3e, 0x7c, 0xd9, + 0x18, 0xfb, 0xe4, 0x65, 0x63, 0xec, 0xaf, 0x2f, 0x1b, 0x63, 0x3f, 0xf8, 0x5a, 0x88, 0x45, 0xa7, + 0xdb, 0xb6, 0x7d, 0x1a, 0xeb, 0xaf, 0xae, 0xce, 0x20, 0xee, 0x46, 0xfe, 0xd1, 0xb4, 0xf7, 0x8e, + 0xf3, 0x64, 0xf8, 0xcb, 0xa9, 0xfa, 0xd2, 0xd4, 0x9e, 0x52, 0xa7, 0xfe, 0x2f, 0xfd, 0x27, 0x00, + 0x00, 0xff, 0xff, 0xd1, 0xa2, 0x3a, 0x05, 0xb5, 0x16, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -2146,6 +2166,18 @@ func (m *MsgConsumerAddition) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if m.AllowInactiveVals { + i-- + if m.AllowInactiveVals { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xa8 + } if m.MaxRank != 0 { i = encodeVarintTx(dAtA, i, uint64(m.MaxRank)) i-- @@ -2689,6 +2721,16 @@ func (m *MsgConsumerModification) MarshalToSizedBuffer(dAtA []byte) (int, error) _ = i var l int _ = l + if m.AllowInactiveVals { + i-- + if m.AllowInactiveVals { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x60 + } if m.MaxRank != 0 { i = encodeVarintTx(dAtA, i, uint64(m.MaxRank)) i-- @@ -2984,6 +3026,9 @@ func (m *MsgConsumerAddition) Size() (n int) { if m.MaxRank != 0 { n += 2 + sovTx(uint64(m.MaxRank)) } + if m.AllowInactiveVals { + n += 3 + } return n } @@ -3199,6 +3244,9 @@ func (m *MsgConsumerModification) Size() (n int) { if m.MaxRank != 0 { n += 1 + sovTx(uint64(m.MaxRank)) } + if m.AllowInactiveVals { + n += 2 + } return n } @@ -4569,6 +4617,26 @@ func (m *MsgConsumerAddition) Unmarshal(dAtA []byte) error { break } } + case 21: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AllowInactiveVals", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.AllowInactiveVals = bool(v != 0) default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -5971,6 +6039,26 @@ func (m *MsgConsumerModification) Unmarshal(dAtA []byte) error { break } } + case 12: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AllowInactiveVals", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.AllowInactiveVals = bool(v != 0) default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:])