From af83b05f4d1b7ca28fd9afdebeec98be08f7b951 Mon Sep 17 00:00:00 2001 From: Giuseppe Natale <12249307+giunatale@users.noreply.github.com> Date: Wed, 29 Jul 2026 16:00:19 +0200 Subject: [PATCH] tighten downtime anchoring, challenge lookup, and double-vote age policy windowEndTimestamp now rejects downtime evidence whose window-end height predates the client's retained consensus states -- i.e. when no consensus state at a height <= window-end is stored to bracket the upper anchor. A pruned or sparse client could otherwise anchor the age/grace checks to a state far above window-end, understating the evidence's age and letting genuinely-stale evidence pass. The timestamp itself now comes from the bracketing lower state rather than the upper one: consumer block times rise with height, so that state's timestamp is a verified lower bound on the true window-end time and the computed age can never come out smaller than the real one. That removes the forward skew entirely, which is what makes the published retention figure honest -- a challenger's worst case is DowntimeEvidenceMaxAge + DowntimeChallengeWindow plus the window's own span, not that plus an unbounded anchor skew. The upper state is still required, as proof the consumer actually reached the window end. The downtime challenge lookup no longer depends on the live consumer-addr to provider-addr key-assignment mapping being intact. The reporting validator's consumer consensus address is now stored on the pending slash and matched on when the fast-path (provider-addr keyed) lookup misses, so a legit slash stays cancellable after the mapping is pruned or the validator rotates its consumer key. The stored address is self-authenticated by the challenge's signature check. The challenge CLI now defaults the header's trusted height to the highest consensus-state height the consumer's client stores below claimed_height+1, instead of the client's latest height -- with an active relayer the latest height is usually already at or past the header, which the light client rejects, so the old default never verified. An explicit --trusted-height must be below claimed_height+1 or the command errors before broadcasting. Trusted validators are now fetched at trusted_height+1: the light client checks them against the trusted consensus state's NextValidatorsHash -- the hash of the next height's set -- so fetching at the trusted height itself only verified when the valset happened not to change across it. Double-vote evidence stays unbounded by age on purpose: it is a permanent cryptographic fault, punished whenever proven, made one-time by the tombstone, and already floored by the per-consumer min height. Document that asymmetry with the age-bounded downtime path. The infraction parameters are no longer frozen at genesis. A new MsgUpdateInfractionParams replaces them in full under the module authority, so every slash fraction, jail duration, tombstone flag, SLA window, challenge window and evidence max age can respond to an incident without a coordinated binary upgrade. They get their own message rather than riding on MsgUpdateParams because they are stored and exported as their own state item: a fee or epoch change need not restate the slashing policy, and vice versa. QueryParams now reports them alongside Params so a proposal author can read what is in force. Validation on that path is the genesis validation, plus the cross-parameter constraints the split creates. InfractionParameters.Validate covers the set itself; ValidateInfractionParamsAgainst then checks the challengeable interval (evidence max age + challenge window) against the incoming or stored trusting-period fraction, from both handlers -- so MsgUpdateParams can no longer lower the fraction out from under the stored infraction parameters, which genesis validates as a pair but nothing enforced at runtime. Widening the challengeable interval is additionally checked against the consumer clients already adopted: a proposal reaching past the trusting period of a pinned client would leave the oldest challengeable header unverifiable there, so pending slashes on that consumer would execute undefended, and the provider does not re-adopt a client to repair it. Narrowing stays unconditionally allowed, so a chain already holding a client too short for its parameters can still correct itself. This finally makes the change-tolerance machinery reachable. SetInfractionParams records the superseded SLA in PreviousDowntimeParams, and AcceptableDowntimeParams keeps accepting evidence echoing it for evidence-max-age + challenge-window after the change; neither had a non-genesis caller before. Evidence spanning a change is judged by the threshold its echoed values imply, not the live one. Tests: sparse-anchor rejection, bracketed-anchor acceptance, and the anchor landing on the highest state at or below window-end; challenge succeeds after the key-assignment mapping is pruned; an old but above-min-height double-sign still slashes a bonded validator; the trusted-height pick takes the highest stored height below the header and skips other revisions; authority gating and full validation of MsgUpdateInfractionParams; MsgUpdateParams rejecting a trusting fraction that strands the stored infraction parameters; widening past a pinned client's trusting period rejected while narrowing and a fitting widening pass; PreviousDowntimeParams written on an SLA change and not on any other; and end-to-end acceptance of in-flight evidence echoing a superseded SLA, with rejection once the tolerance horizon elapses. --- docs/consumer-downtime.md | 89 ++- proto/vaas/provider/v1/provider.proto | 6 + proto/vaas/provider/v1/query.proto | 4 + proto/vaas/provider/v1/tx.proto | 36 + tests/e2e/e2e_downtime_slash_test.go | 2 +- tests/e2e/e2e_setup_test.go | 19 +- x/vaas/provider/client/cli/tx.go | 120 +++- x/vaas/provider/client/cli/tx_test.go | 81 +++ .../provider/keeper/consumer_equivocation.go | 25 +- .../keeper/consumer_equivocation_test.go | 87 +++ x/vaas/provider/keeper/downtime.go | 68 +- x/vaas/provider/keeper/downtime_challenge.go | 85 ++- .../keeper/downtime_challenge_test.go | 104 +++ x/vaas/provider/keeper/downtime_test.go | 71 ++ x/vaas/provider/keeper/grpc_query.go | 6 +- x/vaas/provider/keeper/grpc_query_test.go | 22 + x/vaas/provider/keeper/msg_server.go | 51 ++ x/vaas/provider/keeper/msg_server_test.go | 281 ++++++++ x/vaas/provider/keeper/params.go | 57 ++ .../keeper/window_end_timestamp_test.go | 66 +- x/vaas/provider/types/codec.go | 1 + x/vaas/provider/types/msg.go | 14 + x/vaas/provider/types/msg_test.go | 57 ++ x/vaas/provider/types/params.go | 9 +- x/vaas/provider/types/provider.pb.go | 287 ++++---- x/vaas/provider/types/query.pb.go | 402 ++++++----- x/vaas/provider/types/tx.pb.go | 641 ++++++++++++++---- 27 files changed, 2210 insertions(+), 481 deletions(-) create mode 100644 x/vaas/provider/client/cli/tx_test.go diff --git a/docs/consumer-downtime.md b/docs/consumer-downtime.md index e11c12aa..7106b79a 100644 --- a/docs/consumer-downtime.md +++ b/docs/consumer-downtime.md @@ -72,11 +72,16 @@ on, so the provider owns them: - The consumer's `MsgUpdateParams` preserves the stored values; they are not locally changeable. -Because an update can race in-flight evidence, packets echo the params they were computed -under, and the provider accepts evidence computed under either its current values or the -immediately previous ones (within the evidence-age horizon). Staged values are validated -before activation: a malformed update (zero window, out-of-range fraction) is logged and -dropped rather than applied. +Governance changes them with `MsgUpdateInfractionParams` (section 8). Because a change can +race in-flight evidence, packets echo the params they were computed under, and the provider +accepts evidence computed under either its current values or the immediately previous ones. +The superseded pair is recorded with the block time of the change and stays acceptable for +`DowntimeEvidenceMaxAge + DowntimeChallengeWindow` afterwards -- exactly as long as evidence +computed under it could still be inside its own challenge window. A packet is always judged +by the threshold its echoed values imply, never by the live one, so widening the window +mid-flight neither retroactively excuses nor retroactively creates an infraction. Staged +values are validated before activation: a malformed update (zero window, out-of-range +fraction) is logged and dropped rather than applied. ## 3. Provider validation of incoming evidence @@ -89,11 +94,22 @@ acknowledgement at the first failure: 3. **Identity** -- the consumer consensus address maps to a known provider validator that is in this consumer's validator set; the window end respects the consumer's minimum evidence height. -4. **Time anchoring** -- the window-end timestamp is taken from the smallest stored consensus - state at or above the window-end height (the IBC client's own verified history). Against - that anchor: the window must end after the launch grace period +4. **Time anchoring** -- the window-end height must be *bracketed* by two consensus states + the provider's IBC client for this consumer still stores, each doing a different job. The + smallest stored height at or above the window end proves the consumer chain actually + reached it. The largest stored height at or below it supplies the timestamp: consumer + block times rise with height, so that state's timestamp is a verified lower bound on the + true window-end time, and the anchor can therefore never place the window end later than + it really was. Against that anchor: the window must end after the launch grace period (`SpawnTime + DowntimeGracePeriod`), and must be no older than `DowntimeEvidenceMaxAge` at receipt -- old windows are rejected because their challenge data availability decays. + Anchoring to the upper state instead would overstate the window-end time by however far + the client skipped past it, understating the evidence's age by the same amount and + admitting evidence whose challenge data is already gone; anchoring to the lower state + biases the error the safe way, so a computed age is never smaller than the real one. + Evidence whose window end is not bracketed -- typically because the states around it + expired and were pruned, or because relaying was idle across the window -- is rejected + with `cannot anchor downtime evidence window`; section 9 covers how to read that. 5. **No re-acceptance** -- the window must not intersect any window already accepted for this validator on this consumer (`AcceptedDowntimeWindows`, one record per accepted window, written at acceptance), and must start above the pair's pruned acceptance floor @@ -295,18 +311,52 @@ them along with the escrow records. | `DowntimeEvidenceMaxAge` | provider `InfractionParameters` | `(0, DowntimeChallengeWindow]` | 3 days | | `MaxPauseDuration` | provider module param | `> 0` | 30 days | +Every `InfractionParameters` row is governance-updatable on a running chain with +`MsgUpdateInfractionParams`, which replaces the set in full and revalidates it; the values in +force are readable from the provider `params` query. They live outside the module `Params` +because they are stored (and exported) as their own state item, so a fee or epoch change need +not restate the slashing policy and vice versa. + +What an update reaches differs by parameter, which matters when governance is responding to an +incident with slashes already queued. A pending slash carries the maturity timestamp it was +stamped with at acceptance, so changing `DowntimeChallengeWindow` neither accelerates nor +delays anything already pending -- it only sizes the window for evidence accepted afterwards +(the same holds for withheld-fee-record expiries). `Downtime.SlashFraction`, by contrast, is +the cap applied when a matured entry executes, so lowering it does limit slashes already +queued, and raising it can let them execute closer to their priced amount -- never above it, +since the token amount was fixed at receipt. + `DowntimeEvidenceMaxAge <= DowntimeChallengeWindow` is enforced at validation time: were evidence allowed to be older than the challenge window, a consumer could re-submit a window whose previous slash had already matured while the window was still fresh enough to accept. -The sum of the two must also stay below the consumer client trusting period (checked against -the default consumer unbonding at genesis; per-consumer deviations are operator guidance), -so the oldest challengeable header remains light-client verifiable through the end of its -challenge window. +The sum of the two -- the *challengeable interval*, how far back a challenge may have to reach +-- must also stay below the consumer client trusting period, so the oldest challengeable header +remains light-client verifiable through the end of its challenge window. That constraint spans +both halves of the configuration, so both governance messages enforce it against the stored +other half: `MsgUpdateInfractionParams` against the stored `Params.TrustingPeriodFraction`, and +`MsgUpdateParams` against the stored infraction parameters. Neither half can be moved out from +under the other one proposal at a time. + +That check bounds the interval by the trusting period derived from the *default* consumer +unbonding period, i.e. it constrains the parameters in the abstract. A proposal that *widens* +the interval is checked once more against the clients that actually exist: if the new interval +would reach past the trusting period of a consumer client the provider has already adopted, the +proposal is rejected and names that consumer. Such an interval would leave the oldest +challengeable header unverifiable on that consumer, so its pending slashes would execute +undefended, and the provider does not re-adopt a client to repair it afterwards. Narrowing the +interval is never blocked, whatever the adopted clients look like -- it can only move the +interval further inside every trusting period, and a chain that somehow holds a client too +short for its current parameters has to be able to correct itself. ## 9. Operator guidance -- **Retain blocks.** A challenger must produce the commit for a height up to - `DowntimeEvidenceMaxAge + DowntimeChallengeWindow` in the past (10 days at defaults). +- **Retain blocks.** A challenger must produce the commit for a claimed-missed height. The + oldest one a live accusation can name is `DowntimeEvidenceMaxAge + DowntimeChallengeWindow` + in the past, plus the window's own `SignedBlocksWindow` blocks: evidence is accepted only + while its window end is within `DowntimeEvidenceMaxAge` of now, measured against an anchor + that never understates that age (section 3); the slash then waits out + `DowntimeChallengeWindow`; and the window's first height sits `SignedBlocksWindow` blocks + below its end. At defaults that is 10 days plus one window (600 blocks, about an hour). Validators should configure consumer-node retention (`min-retain-blocks`, pruning) to keep at least that span. - **Watch the acceptance events.** An accepted evidence packet emits the claimed window, @@ -315,6 +365,17 @@ challenge window. A validator that was online should challenge well inside the window. - **Keep clients fresh during pauses.** Relayers have no packet traffic on a paused consumer; updating the clients anyway avoids the `MsgRecoverClient` step at resume time. +- **Read `cannot anchor downtime evidence window` as client coverage, not validator + behavior.** The provider rejected an accusation because it could not bracket the window end + between two stored consensus states for that consumer's client -- normally because no state + sits at or below the window end, the states around it having expired and been pruned, or + relaying having been idle across the window. Nothing is at stake for the accused validator: + the packet was refused with an error acknowledgement, so no slash was ever queued. The + remedy is on the relaying side: a client that takes at least one update per evidence window + brackets every window. A sparse client also drags the anchor down toward its last stored + state, spending part of the `DowntimeEvidenceMaxAge` budget and possibly rejecting otherwise + fresh evidence as too old; the effect is bounded by the client's update interval, which is + one epoch while packets are flowing -- negligible against the 3-day default. ## 10. Trust boundaries diff --git a/proto/vaas/provider/v1/provider.proto b/proto/vaas/provider/v1/provider.proto index a9e63e42..b6c02cdf 100644 --- a/proto/vaas/provider/v1/provider.proto +++ b/proto/vaas/provider/v1/provider.proto @@ -268,6 +268,12 @@ message PendingDowntimeSlash { ]; google.protobuf.Timestamp matures_at = 8 [ (gogoproto.nullable) = false, (gogoproto.stdtime) = true ]; + // consumer_cons_addr is the reporting validator's consensus address on the + // consumer chain, captured at acceptance. A challenge names this address, + // and provider_cons_addr above is derived from it through the key-assignment + // mapping; storing it lets the challenge find this slash even after that + // mapping is pruned or the validator rotates its consumer key. + bytes consumer_cons_addr = 9; } // AcceptedDowntimeWindow records one downtime-detection window whose evidence diff --git a/proto/vaas/provider/v1/query.proto b/proto/vaas/provider/v1/query.proto index 57e4e804..4f7e0f72 100644 --- a/proto/vaas/provider/v1/query.proto +++ b/proto/vaas/provider/v1/query.proto @@ -242,6 +242,10 @@ message QueryParamsRequest {} message QueryParamsResponse { Params params = 1 [(gogoproto.nullable) = false]; + // The infraction parameters, stored separately from params and updated by + // their own governance message (MsgUpdateInfractionParams), so a proposer + // can read the values in force before proposing a change. + InfractionParameters infraction_parameters = 2 [(gogoproto.nullable) = false]; } message QueryConsumerValidatorsRequest { diff --git a/proto/vaas/provider/v1/tx.proto b/proto/vaas/provider/v1/tx.proto index 4ed4da04..fa22627d 100644 --- a/proto/vaas/provider/v1/tx.proto +++ b/proto/vaas/provider/v1/tx.proto @@ -29,6 +29,7 @@ service Msg { rpc UpdateConsumer(MsgUpdateConsumer) returns (MsgUpdateConsumerResponse); rpc RemoveConsumer(MsgRemoveConsumer) returns (MsgRemoveConsumerResponse); rpc UpdateParams(MsgUpdateParams) returns (MsgUpdateParamsResponse); + rpc UpdateInfractionParams(MsgUpdateInfractionParams) returns (MsgUpdateInfractionParamsResponse); rpc SetConsumerFeesPerBlock(MsgSetConsumerFeesPerBlock) returns (MsgSetConsumerFeesPerBlockResponse); rpc FundConsumerFeePool(MsgFundConsumerFeePool) returns (MsgFundConsumerFeePoolResponse); rpc WithdrawConsumerFeePool(MsgWithdrawConsumerFeePool) returns (MsgWithdrawConsumerFeePoolResponse); @@ -105,6 +106,41 @@ message MsgUpdateParams { message MsgUpdateParamsResponse {} +// MsgUpdateInfractionParams is the Msg/UpdateInfractionParams request type. It +// replaces the provider's infraction parameters in full: the slash/jail policy +// for consumer double-signs and downtime, the downtime SLA window, the +// challenge window and the evidence max age. +// +// The infraction parameters are stored as their own state item rather than +// inside Params, so they get their own governance message: a fee or epoch +// change need not restate the whole slashing policy, and vice versa. Both +// handlers enforce the cross-parameter constraint the two sides share (see +// ValidateInfractionParamsAgainst), each against the stored other half. +// +// A proposal that widens downtime_evidence_max_age + +// downtime_challenge_window past the trusting period of a consumer client the +// provider has already adopted is rejected: challenges on that consumer would +// no longer verify, so its pending slashes would execute undefended. +// Narrowing is never blocked. +// +// A change to signed_blocks_window or min_signed_per_window redefines the +// downtime SLA consumers compute their bitmaps against. Consumers learn the +// new values from the next VSC packet and activate them at their next window +// boundary, while evidence already in flight echoes the old values; the +// provider keeps accepting those for downtime_evidence_max_age + +// downtime_challenge_window after the change (see AcceptableDowntimeParams). +message MsgUpdateInfractionParams { + option (cosmos.msg.v1.signer) = "authority"; + + // authority is the address of the governance account. + string authority = 1 [(cosmos_proto.scalar) = "cosmos.AddressString"]; + + // infraction_parameters replaces the stored set in full. + InfractionParameters infraction_parameters = 2 [(gogoproto.nullable) = false]; +} + +message MsgUpdateInfractionParamsResponse {} + // MsgRemoveConsumer defines the message used to remove (and stop) a consumer chain. // If it passes, all the consumer chain's state is eventually removed from the provider chain. // Only the governance authority can remove a consumer chain. diff --git a/tests/e2e/e2e_downtime_slash_test.go b/tests/e2e/e2e_downtime_slash_test.go index 7c72adf0..e3cbacd8 100644 --- a/tests/e2e/e2e_downtime_slash_test.go +++ b/tests/e2e/e2e_downtime_slash_test.go @@ -49,7 +49,7 @@ const ( // downtimeChallengeWindow mirrors the provider genesis // downtime_challenge_window: how long an accepted downtime slash stays // pending (and challengeable) before the BeginBlock sweep executes it. - downtimeChallengeWindow = 30 * time.Second + downtimeChallengeWindow = 120 * time.Second // downtimeEvidenceRelaySlack is the allowance for a window-close evidence // packet to be relayed to and accepted by the provider, on top of the // challenge window, when proving that no evidence ever arrived. diff --git a/tests/e2e/e2e_setup_test.go b/tests/e2e/e2e_setup_test.go index 4b6aea59..cbc935ca 100644 --- a/tests/e2e/e2e_setup_test.go +++ b/tests/e2e/e2e_setup_test.go @@ -126,11 +126,20 @@ func (s *IntegrationTestSuite) SetupSuite() { "jail_duration": "0s", "tombstone": false, }, - "downtime_grace_period": "604800s", - "signed_blocks_window": "30", - "min_signed_per_window": "0.500000000000000000", - "downtime_challenge_window": "30s", - "downtime_evidence_max_age": "30s", + "downtime_grace_period": "604800s", + "signed_blocks_window": "30", + "min_signed_per_window": "0.500000000000000000", + // Both are wide enough to absorb relay latency plus the + // window-end anchoring lag: the anchor is the newest + // consensus state at or below the window end, so a window's + // computed age includes however long the client went without + // an update before it. At 30s a slower run can push an + // otherwise-fresh window past the age check, and the + // consumer drops the error-acked evidence without retrying. + // Keep downtimeChallengeWindow in e2e_downtime_slash_test.go + // in step with the challenge window. + "downtime_challenge_window": "120s", + "downtime_evidence_max_age": "120s", } } diff --git a/x/vaas/provider/client/cli/tx.go b/x/vaas/provider/client/cli/tx.go index 21a24f58..b1c34bfe 100644 --- a/x/vaas/provider/client/cli/tx.go +++ b/x/vaas/provider/client/cli/tx.go @@ -27,6 +27,7 @@ import ( "github.com/cosmos/cosmos-sdk/client/tx" "github.com/cosmos/cosmos-sdk/codec" sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/types/query" "github.com/cosmos/cosmos-sdk/version" ) @@ -512,12 +513,15 @@ func NewSweepConsumerFeePoolCmd() *cobra.Command { // verify a challenge (see docs/consumer-downtime.md, "The challenge"): the // canonical commit for the claimed height H (/commit?height=H), the signed // header for H+1 (/commit?height=H+1), the validator set matching that header -// (/validators?height=H+1), and the accused validator's self-authenticating -// pubkey (/validators?height=H). This is client-side tooling: it trusts the -// consumer RPC endpoint to answer honestly, exactly as any light client or -// relayer does -- the assembled message is still independently verified -// on-chain by HandleChallengeConsumerDowntime, so a dishonest RPC endpoint -// can at worst waste the challenger's gas, never forge a false challenge. +// (/validators?height=H+1), the trusted validator set for the header's +// trusted height T (/validators?height=T+1 -- the set the client's consensus +// state at T commits to through its NextValidatorsHash), and the accused +// validator's self-authenticating pubkey (/validators?height=H). This is +// client-side tooling: it trusts the consumer RPC endpoint to answer +// honestly, exactly as any light client or relayer does -- the assembled +// message is still independently verified on-chain by +// HandleChallengeConsumerDowntime, so a dishonest RPC endpoint can at worst +// waste the challenger's gas, never forge a false challenge. func NewChallengeConsumerDowntimeCmd() *cobra.Command { cmd := &cobra.Command{ Use: "challenge-consumer-downtime [consumer-id] [validator-cons-addr] [claimed-height]", @@ -528,10 +532,11 @@ H, the light-client header for H+1, and the relevant validator sets from the consumer chain's own RPC endpoint (--%s), then assembles and broadcasts MsgChallengeConsumerDowntime. -The H+1 header's trusted height defaults to the provider's currently -tracked latest height for this consumer's IBC client (queried on-chain); -pass --%s to override it, e.g. if that client's light-client module trails -behind the consumer chain tip. +The H+1 header carries a trusted height: a height below H+1 at which the +provider's IBC client for this consumer stores a consensus state to verify +the header against. It defaults to the highest such stored height (queried +on-chain); pass --%s to pick a different one, which must also be below H+1 +and have a stored consensus state. Example: %s tx provider challenge-consumer-downtime 0 cosmosvalcons1... 12345 --%s http://consumer-rpc:26657 @@ -618,9 +623,13 @@ Example: } // The trusted height for the H+1 header: --trusted-height if given, - // else the provider's currently tracked latest height for this - // consumer's IBC client. The client state is queried regardless, to - // source the revision number for the trusted height. + // else the highest height below H+1 at which the provider's client + // for this consumer stores a consensus state. The light client + // verifies the header against the consensus state at the trusted + // height, so only a stored height strictly below the header's own + // works. The client state is queried regardless, to source the + // revision number (a trusted height must sit in the header's own + // revision) and to fail fast on a non-tendermint client. chainResp, err := types.NewQueryClient(clientCtx).QueryConsumerChain(ctx, &types.QueryConsumerChainRequest{ConsumerId: consumerId}) if err != nil { return fmt.Errorf("looking up client id for consumer %d: %w", consumerId, err) @@ -628,7 +637,8 @@ Example: if chainResp.ClientId == "" { return fmt.Errorf("consumer %d has no registered IBC client", consumerId) } - clientStateResp, err := clienttypes.NewQueryClient(clientCtx).ClientState(ctx, &clienttypes.QueryClientStateRequest{ClientId: chainResp.ClientId}) + ibcClientQuerier := clienttypes.NewQueryClient(clientCtx) + clientStateResp, err := ibcClientQuerier.ClientState(ctx, &clienttypes.QueryClientStateRequest{ClientId: chainResp.ClientId}) if err != nil { return fmt.Errorf("querying client state for client %s: %w", chainResp.ClientId, err) } @@ -641,18 +651,43 @@ Example: return fmt.Errorf("client %s is not a tendermint client", chainResp.ClientId) } - trustedHeight := tmClientState.LatestHeight - if h, err := cmd.Flags().GetUint64(FlagTrustedHeight); err == nil && h != 0 { - trustedHeight = clienttypes.NewHeight(tmClientState.LatestHeight.RevisionNumber, h) + headerHeight := clienttypes.NewHeight(tmClientState.LatestHeight.RevisionNumber, uint64(nextHeight)) + trustedHeightOverride, err := cmd.Flags().GetUint64(FlagTrustedHeight) + if err != nil { + return err + } + var trustedHeight clienttypes.Height + if trustedHeightOverride != 0 { + trustedHeight = clienttypes.NewHeight(headerHeight.RevisionNumber, trustedHeightOverride) + if trustedHeight.GTE(headerHeight) { + return fmt.Errorf("--%s %d is not below the header height %d (claimed-height+1); the light client rejects a header at or below its trusted height", + FlagTrustedHeight, trustedHeightOverride, nextHeight) + } + } else { + consensusHeights, err := fetchConsensusStateHeights(ctx, ibcClientQuerier, chainResp.ClientId) + if err != nil { + return fmt.Errorf("querying consensus state heights for client %s: %w", chainResp.ClientId, err) + } + var found bool + trustedHeight, found = highestHeightBelow(consensusHeights, headerHeight) + if !found { + return fmt.Errorf("client %s stores no consensus state below height %d (claimed-height+1); the claimed height predates every state the client retains, so the header cannot be verified against it", + chainResp.ClientId, nextHeight) + } } - trustedVals, err := fetchAllValidators(ctx, rpcClient, int64(trustedHeight.RevisionHeight)) + // The light client checks TrustedValidators against the consensus + // state at the trusted height T through that state's + // NextValidatorsHash -- the hash of the validator set at T+1 -- so + // the set is fetched at T+1, not T. + trustedValsHeight := int64(trustedHeight.RevisionHeight) + 1 + trustedVals, err := fetchAllValidators(ctx, rpcClient, trustedValsHeight) if err != nil { - return fmt.Errorf("fetching validators at trusted height %d: %w", trustedHeight.RevisionHeight, err) + return fmt.Errorf("fetching validators at height %d (trusted height + 1): %w", trustedValsHeight, err) } trustedValSet, err := tmtypes.NewValidatorSet(trustedVals).ToProto() if err != nil { - return fmt.Errorf("converting validator set at trusted height %d: %w", trustedHeight.RevisionHeight, err) + return fmt.Errorf("converting validator set at height %d: %w", trustedValsHeight, err) } header := &ibctmtypes.Header{ @@ -681,7 +716,7 @@ Example: cmd.Flags().String(FlagConsumerRPC, "", "CometBFT RPC endpoint of the consumer chain (required)") cmd.Flags().Uint64(FlagTrustedHeight, 0, - "trusted height for the H+1 light-client header (default: the provider's tracked latest height for this consumer's client)") + "trusted height for the H+1 light-client header; must be below claimed-height+1 and have a consensus state stored on the provider's client for this consumer (default: the highest such height)") flags.AddTxFlagsToCmd(cmd) _ = cmd.MarkFlagRequired(flags.FlagFrom) _ = cmd.MarkFlagRequired(FlagConsumerRPC) @@ -709,3 +744,46 @@ func fetchAllValidators(ctx context.Context, rpcClient *rpchttp.HTTP, height int page++ } } + +// fetchConsensusStateHeights pages through the provider's +// ibc.core.client.v1.Query/ConsensusStateHeights endpoint to return every +// height at which the client identified by clientId stores a consensus +// state. Pages arrive in store-key order, not numeric height order, so the +// full list is needed before choosing among the heights. +func fetchConsensusStateHeights(ctx context.Context, queryClient clienttypes.QueryClient, clientId string) ([]clienttypes.Height, error) { + var heights []clienttypes.Height + var nextKey []byte + for { + res, err := queryClient.ConsensusStateHeights(ctx, &clienttypes.QueryConsensusStateHeightsRequest{ + ClientId: clientId, + Pagination: &query.PageRequest{Key: nextKey}, + }) + if err != nil { + return nil, err + } + heights = append(heights, res.ConsensusStateHeights...) + if res.Pagination == nil || len(res.Pagination.NextKey) == 0 { + return heights, nil + } + nextKey = res.Pagination.NextKey + } +} + +// highestHeightBelow returns the highest of heights that shares bound's +// revision number and sits strictly below it, and whether any does. Heights +// from other revisions never qualify: the light client only accepts a +// trusted height in the same revision as the header being verified. +func highestHeightBelow(heights []clienttypes.Height, bound clienttypes.Height) (clienttypes.Height, bool) { + var best clienttypes.Height + found := false + for _, h := range heights { + if h.RevisionNumber != bound.RevisionNumber || h.RevisionHeight >= bound.RevisionHeight { + continue + } + if !found || h.GT(best) { + best = h + found = true + } + } + return best, found +} diff --git a/x/vaas/provider/client/cli/tx_test.go b/x/vaas/provider/client/cli/tx_test.go new file mode 100644 index 00000000..375a7e63 --- /dev/null +++ b/x/vaas/provider/client/cli/tx_test.go @@ -0,0 +1,81 @@ +package cli + +import ( + "testing" + + "github.com/stretchr/testify/require" + + clienttypes "github.com/cosmos/ibc-go/v10/modules/core/02-client/types" +) + +func TestHighestHeightBelow(t *testing.T) { + bound := clienttypes.NewHeight(1, 100) + + testCases := []struct { + name string + heights []clienttypes.Height + wantHeight clienttypes.Height + wantFound bool + }{ + { + name: "no heights", + heights: nil, + wantFound: false, + }, + { + name: "all heights at or above the bound", + heights: []clienttypes.Height{ + clienttypes.NewHeight(1, 100), + clienttypes.NewHeight(1, 250), + }, + wantFound: false, + }, + { + name: "picks the highest height below the bound, in any input order", + heights: []clienttypes.Height{ + clienttypes.NewHeight(1, 40), + clienttypes.NewHeight(1, 99), + clienttypes.NewHeight(1, 7), + clienttypes.NewHeight(1, 150), + }, + wantHeight: clienttypes.NewHeight(1, 99), + wantFound: true, + }, + { + name: "a height equal to the bound does not qualify", + heights: []clienttypes.Height{ + clienttypes.NewHeight(1, 100), + clienttypes.NewHeight(1, 60), + }, + wantHeight: clienttypes.NewHeight(1, 60), + wantFound: true, + }, + { + name: "heights from other revisions never qualify", + heights: []clienttypes.Height{ + clienttypes.NewHeight(0, 99), + clienttypes.NewHeight(2, 1), + }, + wantFound: false, + }, + { + name: "same-revision height wins over a numerically larger one from an older revision", + heights: []clienttypes.Height{ + clienttypes.NewHeight(0, 5000), + clienttypes.NewHeight(1, 3), + }, + wantHeight: clienttypes.NewHeight(1, 3), + wantFound: true, + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + got, found := highestHeightBelow(tc.heights, bound) + require.Equal(t, tc.wantFound, found) + if tc.wantFound { + require.Equal(t, tc.wantHeight, got) + } + }) + } +} diff --git a/x/vaas/provider/keeper/consumer_equivocation.go b/x/vaas/provider/keeper/consumer_equivocation.go index f287c7e6..ee8af2d5 100644 --- a/x/vaas/provider/keeper/consumer_equivocation.go +++ b/x/vaas/provider/keeper/consumer_equivocation.go @@ -43,7 +43,25 @@ func (k Keeper) HandleConsumerDoubleVoting( ) } - // check that the evidence is not too old + // Reject evidence below the per-consumer minimum height (set at launch and + // on each resync), which is the ONLY age bound on equivocation. Unlike + // downtime -- which additionally bounds evidence by DowntimeEvidenceMaxAge + // (see HandleConsumerDowntime) -- double-signing has no maximum-age bound, + // and this asymmetry is intentional: + // + // - Equivocation is a permanent, self-contained cryptographic fault: the + // two conflicting signed votes prove it forever, so it is punished + // whenever proven. The tombstone applied below makes punishment + // one-time (a re-submitted old evidence hits the already-tombstoned + // path and is a no-op), so there is no re-slash risk from stale + // evidence, and the min-height gate already blocks evidence from before + // the validator was in the consumer's set. + // - Downtime is a liveness signal priced against a specific epoch and + // resolved through a challenge window; letting arbitrarily old downtime + // evidence in would misprice it and reopen a settled window, so it is + // age-bounded. + // + // Do not add a maximum-age bound here without revisiting that reasoning. minHeight := k.GetEquivocationEvidenceMinHeight(ctx, consumerId) if uint64(evidence.VoteA.Height) < minHeight { return errorsmod.Wrapf( @@ -127,7 +145,10 @@ func (k Keeper) VerifyDoubleVotingEvidence( ) } - // Note the age of the evidence isn't checked. + // The age of the evidence is deliberately not checked here: equivocation is + // punished whenever proven, with only the per-consumer min-height gate in + // HandleConsumerDoubleVoting bounding it. See the asymmetry-with-downtime + // note there. // height/round/type must be the same if evidence.VoteA.Height != evidence.VoteB.Height || diff --git a/x/vaas/provider/keeper/consumer_equivocation_test.go b/x/vaas/provider/keeper/consumer_equivocation_test.go index 26581a21..8946fc90 100644 --- a/x/vaas/provider/keeper/consumer_equivocation_test.go +++ b/x/vaas/provider/keeper/consumer_equivocation_test.go @@ -321,6 +321,93 @@ func TestVerifyDoubleVotingEvidence(t *testing.T) { } } +// TestHandleConsumerDoubleVotingSlashesOldButAboveMinHeightEvidence confirms +// the intentional asymmetry documented in HandleConsumerDoubleVoting: double +// voting evidence carries NO maximum-age bound, so a still-bonded validator's +// equivocation is slashed, jailed, and tombstoned whenever proven -- even when +// the votes are far older than any downtime-style max age -- as long as the +// evidence height clears the per-consumer minimum-height gate. Contrast the +// downtime path, which rejects evidence older than DowntimeEvidenceMaxAge. +func TestHandleConsumerDoubleVotingSlashesOldButAboveMinHeightEvidence(t *testing.T) { + providerKeeper, ctx, ctrl, mocks := testkeeper.GetProviderKeeperAndCtx(t, testkeeper.NewInMemKeeperParams(t)) + defer ctrl.Finish() + + const ( + chainID = "consumer-chain-0" + consumerID = uint64(0) + minHeight = uint64(5) + evidenceHeight = int64(100) // well above minHeight + ) + + providerKeeper.SetConsumerPhase(ctx, consumerID, types.CONSUMER_PHASE_LAUNCHED) + providerKeeper.SetConsumerChainId(ctx, consumerID, chainID) + providerKeeper.SetEquivocationEvidenceMinHeight(ctx, consumerID, minHeight) + providerKeeper.SetInfractionParams(ctx, *getTestInfractionParameters()) + + // The votes are signed with a long-past block time while the provider's + // current block time is years later. The double-vote path never compares + // the two, so this staleness must not prevent the slash. + oldVoteTime := time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC) + ctx = ctx.WithBlockTime(time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC)) + + signer := tmtypes.NewMockPV() + val := tmtypes.NewValidator(signer.PrivKey.PubKey(), 1) + valSet := tmtypes.NewValidatorSet([]*tmtypes.Validator{val}) + valPubkey, err := cryptocodec.FromCmtPubKeyInterface(val.PubKey) + require.NoError(t, err) + + blockID1 := cryptotestutil.MakeBlockID([]byte("blockhash1"), 1000, []byte("partshash")) + blockID2 := cryptotestutil.MakeBlockID([]byte("blockhash2"), 1000, []byte("partshash")) + evidence := &tmtypes.DuplicateVoteEvidence{ + VoteA: cryptotestutil.MakeAndSignVote(blockID1, evidenceHeight, oldVoteTime, valSet, signer, chainID), + VoteB: cryptotestutil.MakeAndSignVote(blockID2, evidenceHeight, oldVoteTime, valSet, signer, chainID), + ValidatorPower: val.VotingPower, + TotalVotingPower: val.VotingPower, + Timestamp: oldVoteTime, + } + + // Build the bonded staking validator whose consensus key matches the signer, + // so the provider consensus address resolves to it (no key assignment). + stakingVal, err := stakingtypes.NewValidator( + sdk.ValAddress(valPubkey.Address()).String(), + valPubkey, + stakingtypes.NewDescription("", "", "", "", ""), + ) + require.NoError(t, err) + stakingVal.Status = stakingtypes.Bonded + stakingVal.Tokens = sdk.DefaultPowerReduction + stakingVal.DelegatorShares = math.LegacyNewDecFromInt(sdk.DefaultPowerReduction) + consAddr, err := stakingVal.GetConsAddr() + require.NoError(t, err) + + mocks.MockStakingKeeper.EXPECT().GetValidatorByConsAddr(gomock.Any(), sdk.ConsAddress(consAddr)).Return(stakingVal, nil).AnyTimes() + mocks.MockSlashingKeeper.EXPECT().IsTombstoned(gomock.Any(), sdk.ConsAddress(consAddr)).Return(false).AnyTimes() + mocks.MockStakingKeeper.EXPECT().GetUnbondingDelegationsFromValidator(gomock.Any(), gomock.Any()).Return([]stakingtypes.UnbondingDelegation{}, nil).AnyTimes() + mocks.MockStakingKeeper.EXPECT().GetRedelegationsFromSrcValidator(gomock.Any(), gomock.Any()).Return([]stakingtypes.Redelegation{}, nil).AnyTimes() + mocks.MockStakingKeeper.EXPECT().GetLastValidatorPower(gomock.Any(), gomock.Any()).Return(int64(10), nil).AnyTimes() + mocks.MockStakingKeeper.EXPECT().PowerReduction(gomock.Any()).Return(sdk.DefaultPowerReduction).AnyTimes() + + slashCalled := false + mocks.MockStakingKeeper.EXPECT(). + SlashWithInfractionReason(gomock.Any(), sdk.ConsAddress(consAddr), int64(0), gomock.Any(), getTestInfractionParameters().DoubleSign.SlashFraction, stakingtypes.Infraction_INFRACTION_DOUBLE_SIGN). + DoAndReturn(func(_ sdk.Context, _ sdk.ConsAddress, _ int64, power int64, _ math.LegacyDec, _ stakingtypes.Infraction) (math.Int, error) { + slashCalled = true + return math.NewInt(power), nil + }).Times(1) + + mocks.MockStakingKeeper.EXPECT().Jail(gomock.Any(), sdk.ConsAddress(consAddr)).Return(nil).Times(1) + mocks.MockSlashingKeeper.EXPECT().JailUntil(gomock.Any(), sdk.ConsAddress(consAddr), gomock.Any()).Return(nil).Times(1) + tombstoneCalled := false + mocks.MockSlashingKeeper.EXPECT().Tombstone(gomock.Any(), sdk.ConsAddress(consAddr)).DoAndReturn(func(_ sdk.Context, _ sdk.ConsAddress) error { + tombstoneCalled = true + return nil + }).Times(1) + + require.NoError(t, providerKeeper.HandleConsumerDoubleVoting(ctx, consumerID, evidence, valPubkey)) + require.True(t, slashCalled, "an old but above-min-height double-sign must still slash") + require.True(t, tombstoneCalled, "an old but above-min-height double-sign must still tombstone") +} + // TestJailAndTombstoneValidator tests that the jailing of a validator is only executed // under the conditions that the validator is neither unbonded, nor jailed, nor tombstoned. func TestJailAndTombstoneValidator(t *testing.T) { diff --git a/x/vaas/provider/keeper/downtime.go b/x/vaas/provider/keeper/downtime.go index c60fe014..e46de130 100644 --- a/x/vaas/provider/keeper/downtime.go +++ b/x/vaas/provider/keeper/downtime.go @@ -58,9 +58,10 @@ func (k Keeper) HandleConsumerEvidencePacket(ctx sdk.Context, consumerId uint64, // 3. The window-end height is not older than the minimum evidence height // for this consumer, and the validator was part of the consumer's // validator set. -// 4. The window-end time -- anchored to an IBC consensus state proving the -// consumer chain actually reached that height, see windowEndTimestamp -- -// is past the consumer's downtime grace period and not older than +// 4. The window-end time -- bracketed by IBC consensus states, one proving +// the consumer chain reached the window end and one supplying a verified +// lower bound on when it did, see windowEndTimestamp -- is past the +// consumer's downtime grace period and not older than // DowntimeEvidenceMaxAge. // 5. The window starts above the pair's pruned acceptance floor // (DowntimeWindowFloors) and does not intersect any window already @@ -139,7 +140,7 @@ func (k Keeper) HandleConsumerDowntime(ctx sdk.Context, consumerId uint64, evide ) } - // Anchor the window-end time to a real IBC consensus state so the grace + // Anchor the window-end time to real IBC consensus states so the grace // and evidence-age checks below are judged against consumer chain time // the provider can actually verify, not the packet's own unverified claim. windowEndTime, err := k.windowEndTimestamp(ctx, clientId, evidencePacket.WindowEndHeight) @@ -244,6 +245,7 @@ func (k Keeper) HandleConsumerDowntime(ctx sdk.Context, consumerId uint64, evide pending := types.PendingDowntimeSlash{ ConsumerId: consumerId, ProviderConsAddr: providerAddr.ToSdkConsAddr().Bytes(), + ConsumerConsAddr: consumerAddr.ToSdkConsAddr().Bytes(), WindowStartHeight: evidencePacket.WindowStartHeight, Span: evidencePacket.Span(), MissedCount: evidencePacket.MissedCount(), @@ -334,12 +336,34 @@ func (k Keeper) checkAcceptedDowntimeWindowIntersection( } // windowEndTimestamp resolves the timestamp anchor for a downtime evidence -// window: the timestamp of the smallest IBC consensus state stored for -// clientId at a height >= windowEnd. This proves the consumer chain actually -// reached at least that height, so the grace-period and evidence-age checks -// in HandleConsumerDowntime are judged against verifiable consumer chain -// time rather than the packet's own unverified claims. Returns an error if -// no such consensus state is stored. +// window from the IBC client's own verified history, so the grace-period and +// evidence-age checks in HandleConsumerDowntime are judged against consumer +// chain time the provider can verify rather than the packet's own unverified +// claims. The window-end height must be bracketed by two stored consensus +// states, each playing a distinct part: +// +// - the smallest stored height >= windowEnd proves the consumer chain +// actually reached the window end; +// - the largest stored height <= windowEnd supplies the timestamp returned. +// +// Consumer block timestamps increase with height, so the lower state's +// timestamp is a verified lower bound on the true window-end time while the +// upper state's is an upper bound. Returning the lower bound is what keeps the +// age check honest: the computed age is never smaller than the real one, so +// accepted evidence is genuinely no older than DowntimeEvidenceMaxAge and the +// challenge-data retention a validator must plan for stays exactly +// DowntimeEvidenceMaxAge + DowntimeChallengeWindow. Anchoring to the upper +// state instead would overstate the window-end time by however far the client +// skipped past windowEnd, understating the evidence's age by the same amount +// and admitting evidence whose challenge data has already been pruned. +// Rejections are for the same reason biased safe: an anchor below the true +// window-end time can only reject fresh evidence, never admit stale evidence. +// +// Both anchors are required. A missing upper state means the client cannot +// vouch for the height at all; a missing lower state means windowEnd predates +// every consensus state the client retains -- the states around it expired and +// were pruned, or the client is too sparse there -- leaving no verified lower +// bound to anchor to. func (k Keeper) windowEndTimestamp(ctx sdk.Context, clientId string, windowEnd int64) (time.Time, error) { if k.windowEndTimestampFn != nil { return k.windowEndTimestampFn(ctx, clientId, windowEnd) @@ -347,19 +371,33 @@ func (k Keeper) windowEndTimestamp(ctx sdk.Context, clientId string, windowEnd i clientStore := k.clientKeeper.GetStoreProvider().ClientStore(ctx, clientId) - var anchorHeight ibcexported.Height - found := false + var anchorHeight, upperHeight ibcexported.Height + anchorFound := false + upperFound := false ibctmtypes.IterateConsensusStateAscending(clientStore, func(height ibcexported.Height) bool { - if int64(height.GetRevisionHeight()) >= windowEnd { + revisionHeight := int64(height.GetRevisionHeight()) + if revisionHeight <= windowEnd { + // Iteration is ascending, so the last height at or below windowEnd + // wins; a state at exactly windowEnd anchors the window exactly. anchorHeight = height - found = true + anchorFound = true + } + if revisionHeight >= windowEnd { + upperHeight = height + upperFound = true return true } return false }) - if !found { + if !upperFound { return time.Time{}, fmt.Errorf("cannot anchor evidence window time: no consensus state at height >= %d", windowEnd) } + if !anchorFound { + return time.Time{}, fmt.Errorf( + "cannot anchor evidence window time: window-end height %d predates the client's retained consensus states (nearest stored is %d); evidence is too old or the client too sparse to anchor", + windowEnd, upperHeight.GetRevisionHeight(), + ) + } consensusState, ok := k.clientKeeper.GetClientConsensusState(ctx, clientId, anchorHeight) if !ok { diff --git a/x/vaas/provider/keeper/downtime_challenge.go b/x/vaas/provider/keeper/downtime_challenge.go index 9fecae74..8bd78fb4 100644 --- a/x/vaas/provider/keeper/downtime_challenge.go +++ b/x/vaas/provider/keeper/downtime_challenge.go @@ -64,23 +64,29 @@ func (k Keeper) HandleChallengeConsumerDowntime(ctx sdk.Context, msg *types.MsgC } consumerAddr := types.NewConsumerConsAddress(sdk.ConsAddress(msg.ValidatorAddr)) - providerAddr := k.GetProviderAddrFromConsumerAddr(ctx, msg.ConsumerId, consumerAddr) // 1. among the (possibly several) pending slashes for this validator on // this consumer, find the one whose window contains claimed_height, and - // check that its bitmap marks it missed. - pending, found, err := k.findPendingDowntimeSlashContaining(ctx, msg.ConsumerId, providerAddr.ToSdkConsAddr().Bytes(), msg.ClaimedHeight) + // check that its bitmap marks it missed. The lookup is by consumer + // consensus address so it survives key rotation/pruning of the + // consumer-addr to provider-addr mapping (see findPendingDowntimeSlashContaining). + pending, found, err := k.findPendingDowntimeSlashContaining(ctx, msg.ConsumerId, consumerAddr, msg.ClaimedHeight) if err != nil { return errorsmod.Wrapf(types.ErrDowntimeChallengeFailed, "looking up pending downtime slash for validator %s on consumer chain %d: %s", - providerAddr.String(), msg.ConsumerId, err) + consumerAddr.String(), msg.ConsumerId, err) } if !found { return errorsmod.Wrapf(types.ErrDowntimeChallengeFailed, "no pending downtime slash for validator %s on consumer chain %d claims height %d missed", - providerAddr.String(), msg.ConsumerId, msg.ClaimedHeight) + consumerAddr.String(), msg.ConsumerId, msg.ClaimedHeight) } + // The slash carries the provider consensus address it was keyed under at + // acceptance; use it for logging and events rather than re-resolving + // through key-assignment state that may have changed since. + providerAddr := types.NewProviderConsAddress(sdk.ConsAddress(pending.ProviderConsAddr)) + index := msg.ClaimedHeight - pending.WindowStartHeight if !vaastypes.BitmapIsSet(pending.MissedBlocksBitmap, index) { return errorsmod.Wrapf(types.ErrDowntimeChallengeFailed, @@ -145,15 +151,66 @@ func (k Keeper) HandleChallengeConsumerDowntime(ctx sdk.Context, msg *types.MsgC } // findPendingDowntimeSlashContaining searches the (possibly several) pending -// downtime slashes for (consumerId, providerConsAddr) -- one per accepted -// disjoint window -- for the one whose [WindowStartHeight, -// WindowStartHeight+Span) range contains claimedHeight. Windows for a pair -// are enforced disjoint at acceptance (see the AcceptedDowntimeWindows -// intersection check in HandleConsumerDowntime), so at -// most one match is expected; the sub-range is bounded by however many -// windows are currently pending for this single validator on this single -// consumer. -func (k Keeper) findPendingDowntimeSlashContaining(ctx sdk.Context, consumerId uint64, providerConsAddr []byte, claimedHeight int64) (types.PendingDowntimeSlash, bool, error) { +// downtime slashes for the validator identified by consumerAddr on consumerId +// -- one per accepted disjoint window -- for the one whose [WindowStartHeight, +// WindowStartHeight+Span) range contains claimedHeight. Windows for a +// validator are enforced disjoint at acceptance (see the +// AcceptedDowntimeWindows intersection check in HandleConsumerDowntime), so at +// most one match is expected. +// +// It first resolves the validator's provider consensus address through the +// live key-assignment mapping and scans the slashes keyed under it. This is +// the common path -- and the only path a validator that never assigned a +// custom consumer key ever needs, since its provider and consumer addresses +// coincide. If that finds nothing it falls back to scanning the consumer's +// pending slashes for one whose stored ConsumerConsAddr equals consumerAddr: +// a slash accepted for an assigned consumer key is keyed under the provider +// address resolved at acceptance, so once that mapping is pruned (a later key +// rotation, or the validator leaving the staking set) the live resolution no +// longer reaches it. The consumer address stored on the slash is +// rotation-invariant, and the challenge's own signature check +// self-authenticates it, so the fallback recovers a legit slash without +// trusting current key-assignment state. +func (k Keeper) findPendingDowntimeSlashContaining(ctx sdk.Context, consumerId uint64, consumerAddr types.ConsumerConsAddress, claimedHeight int64) (types.PendingDowntimeSlash, bool, error) { + providerAddr := k.GetProviderAddrFromConsumerAddr(ctx, consumerId, consumerAddr) + pending, found, err := k.findPendingDowntimeSlashUnderProviderAddr(ctx, consumerId, providerAddr.ToSdkConsAddr().Bytes(), claimedHeight) + if err != nil || found { + return pending, found, err + } + + // Fallback: the provider address the slash was keyed under is no longer + // reachable from consumerAddr through live key-assignment state. Match on + // the consumer address captured on each slash at acceptance instead. + consumerAddrBz := consumerAddr.ToSdkConsAddr().Bytes() + iter, err := k.PendingDowntimeSlashes.Iterate( + ctx, collections.NewPrefixedTripleRange[uint64, []byte, int64](consumerId), + ) + if err != nil { + return types.PendingDowntimeSlash{}, false, err + } + defer iter.Close() + + for ; iter.Valid(); iter.Next() { + val, err := iter.Value() + if err != nil { + return types.PendingDowntimeSlash{}, false, err + } + if !bytes.Equal(val.ConsumerConsAddr, consumerAddrBz) { + continue + } + if claimedHeight >= val.WindowStartHeight && claimedHeight < val.WindowStartHeight+val.Span { + return val, true, nil + } + } + return types.PendingDowntimeSlash{}, false, nil +} + +// findPendingDowntimeSlashUnderProviderAddr scans the pending downtime slashes +// keyed under (consumerId, providerConsAddr) for the one whose +// [WindowStartHeight, WindowStartHeight+Span) range contains claimedHeight. +// The sub-range scanned is bounded by however many windows are currently +// pending for this single validator on this single consumer. +func (k Keeper) findPendingDowntimeSlashUnderProviderAddr(ctx sdk.Context, consumerId uint64, providerConsAddr []byte, claimedHeight int64) (types.PendingDowntimeSlash, bool, error) { iter, err := k.PendingDowntimeSlashes.Iterate( ctx, collections.NewSuperPrefixedTripleRange[uint64, []byte, int64](consumerId, providerConsAddr), ) diff --git a/x/vaas/provider/keeper/downtime_challenge_test.go b/x/vaas/provider/keeper/downtime_challenge_test.go index 54d44712..047d8d19 100644 --- a/x/vaas/provider/keeper/downtime_challenge_test.go +++ b/x/vaas/provider/keeper/downtime_challenge_test.go @@ -465,6 +465,110 @@ func TestHandleChallengeConsumerDowntime_SuccessIsolatesOtherConsumer(t *testing require.True(t, hasB, "consumer B's withheld fee record must survive consumer A's successful challenge") } +// TestHandleChallengeConsumerDowntime_SucceedsAfterKeyAssignmentPruned proves +// the pending-slash lookup survives key rotation/pruning. A validator that +// assigned a custom consumer key has its downtime slash keyed under the +// provider consensus address resolved at acceptance. When the +// consumer-addr to provider-addr mapping is later pruned -- a key rotation +// whose old address has aged out of the prune queue, or the validator leaving +// the staking set -- GetProviderAddrFromConsumerAddr falls back to treating the +// consumer address as the provider address, so the direct (fast-path) lookup +// no longer reaches the slash. The challenge must still find it via the +// consumer address stored on the slash and succeed; without that fallback the +// legit slash would be un-cancellable. +func TestHandleChallengeConsumerDowntime_SucceedsAfterKeyAssignmentPruned(t *testing.T) { + k, ctx, ctrl, _ := testkeeper.GetProviderKeeperAndCtx(t, testkeeper.NewInMemKeeperParams(t)) + defer ctrl.Finish() + + k.OverrideVerifyDowntimeChallengeHeaderForTest(func(sdk.Context, string, *ibctmtypes.Header) error { + return nil + }) + + cid := k.FetchAndIncrementConsumerId(ctx) + k.SetConsumerPhase(ctx, cid, types.CONSUMER_PHASE_LAUNCHED) + k.SetConsumerChainId(ctx, cid, challengeTestChainID) + k.SetConsumerClientId(ctx, cid, "07-tendermint-0") + + // The signer holds the validator's CONSUMER key: the challenge names its + // consumer consensus address and its signature self-authenticates it. + signer := tmtypes.NewMockPV() + pubKey, err := signer.GetPubKey() + require.NoError(t, err) + consumerAddr := types.NewConsumerConsAddress(sdk.ConsAddress(pubKey.Address())) + + // The validator's provider consensus address is distinct from its consumer + // address (a custom consumer key was assigned). + providerAddr := types.NewProviderConsAddress(sdk.ConsAddress([]byte("provider-cons-addr-0"))) + require.NotEqual(t, consumerAddr.ToSdkConsAddr().Bytes(), providerAddr.ToSdkConsAddr().Bytes()) + + // Assign the key, confirm the mapping resolves, then prune it: resolution + // now falls back to the consumer address and no longer reaches the slash. + k.SetValidatorByConsumerAddr(ctx, cid, consumerAddr, providerAddr) + resolved := k.GetProviderAddrFromConsumerAddr(ctx, cid, consumerAddr) + require.Equal(t, providerAddr.ToSdkConsAddr().Bytes(), resolved.ToSdkConsAddr().Bytes()) + k.DeleteValidatorByConsumerAddr(ctx, cid, consumerAddr) + fallback := k.GetProviderAddrFromConsumerAddr(ctx, cid, consumerAddr) + require.Equal(t, consumerAddr.ToSdkConsAddr().Bytes(), fallback.ToSdkConsAddr().Bytes()) + + const ( + claimedHeight = int64(100) + windowStart = claimedHeight + span = int64(5) + ) + windowEndHeight := windowStart + span - 1 + // Keyed under the provider address (as HandleConsumerDowntime does), but + // carrying the consumer address the fallback matches on. + pending := types.PendingDowntimeSlash{ + ConsumerId: cid, + ProviderConsAddr: providerAddr.ToSdkConsAddr().Bytes(), + ConsumerConsAddr: consumerAddr.ToSdkConsAddr().Bytes(), + WindowStartHeight: windowStart, + Span: span, + MissedCount: 1, + MissedBlocksBitmap: []byte{0x01}, // bit 0 (claimedHeight - windowStart) marked missed + SlashTokens: math.NewInt(1000), + MaturesAt: ctx.BlockTime().Add(time.Hour), + } + pendingKey := collections.Join3(cid, providerAddr.ToSdkConsAddr().Bytes(), windowEndHeight) + require.NoError(t, k.PendingDowntimeSlashes.Set(ctx, pendingKey, pending)) + + blockID := cryptotestutil.MakeBlockID([]byte("blockhash"), 1, []byte("partshash")) + vote, err := tmtypes.MakeVote(signer, challengeTestChainID, 0, claimedHeight, 0, tmproto.PrecommitType, blockID, ctx.BlockTime()) + require.NoError(t, err) + commit := &tmtypes.Commit{ + Height: claimedHeight, + Round: 0, + BlockID: blockID, + Signatures: []tmtypes.CommitSig{vote.CommitSig()}, + } + header := &ibctmtypes.Header{ + SignedHeader: &tmproto.SignedHeader{ + Header: &tmproto.Header{ + ChainID: challengeTestChainID, + Height: claimedHeight + 1, + LastCommitHash: commit.Hash(), + }, + Commit: &tmproto.Commit{}, + }, + } + msg := &types.MsgChallengeConsumerDowntime{ + Signer: "cosmos1qypqxpq9qcrsszgse4wwrq4vt3s2r0y8ryqhx7", + ConsumerId: cid, + ValidatorAddr: pubKey.Address(), + ClaimedHeight: claimedHeight, + Header: header, + LastCommit: commit.ToProto(), + ValidatorPubkey: pubKey.Bytes(), + } + + // No withheld fee record is seeded, so PayWithheldFees needs no bank/staking + // mocks. Success proves the fallback found the slash despite the pruned map. + require.NoError(t, k.HandleChallengeConsumerDowntime(ctx, msg)) + require.Equal(t, types.CONSUMER_PHASE_PAUSED, k.GetConsumerPhase(ctx, cid)) + _, err = k.PendingDowntimeSlashes.Get(ctx, pendingKey) + require.ErrorIs(t, err, collections.ErrNotFound, "the slash must be found and cancelled despite the pruned key-assignment mapping") +} + // TestHandleChallengeConsumerDowntime_NoPendingSlash verifies step 1: without // a pending slash for the accused validator, the challenge is rejected // before touching any header/commit/signature verification. diff --git a/x/vaas/provider/keeper/downtime_test.go b/x/vaas/provider/keeper/downtime_test.go index 5f07a3da..85bcca4a 100644 --- a/x/vaas/provider/keeper/downtime_test.go +++ b/x/vaas/provider/keeper/downtime_test.go @@ -667,6 +667,77 @@ func TestHandleConsumerEvidencePacketRejectsPausedConsumer(t *testing.T) { require.Error(t, err) } +// TestHandleConsumerDowntimeAcrossGovernanceSLAChange exercises the +// change-tolerance machinery end to end from the governance path: after +// MsgUpdateInfractionParams redefines the downtime SLA, evidence still in +// flight -- computed and echoed under the superseded window -- keeps being +// accepted and is judged against the threshold it was computed under, evidence +// under the new window is accepted too, and once the tolerance horizon elapses +// the superseded window is refused. +func TestHandleConsumerDowntimeAcrossGovernanceSLAChange(t *testing.T) { + windowEndTime := time.Date(2025, 6, 1, 0, 0, 0, 0, time.UTC) + spawnTime := windowEndTime.Add(-30 * 24 * time.Hour) + + oldSLA := types.DefaultInfractionParameters() + oldSLA.SignedBlocksWindow = 8 + oldSLA.MinSignedPerWindow = math.LegacyMustNewDecFromStr("0.5") + oldSLA.DowntimeGracePeriod = 0 + + providerKeeper, ctx, ctrl, mocks, consumerId, providerAddr := setupDowntimeTest(t, oldSLA, spawnTime, windowEndTime) + defer ctrl.Finish() + ctx = ctx.WithBlockTime(windowEndTime) + consAddr := providerAddr.ToSdkConsAddr() + + // Pricing inputs for every accepted window below. + providerKeeper.SetEpochShareRecord(ctx, consumerId, windowEndTime, math.NewInt(1000)) + mocks.MockPhotonKeeper.EXPECT().ConversionRate(gomock.Any()).Return(math.LegacyNewDec(2), nil).AnyTimes() + + // Governance doubles the SLA window, which also doubles the tolerated + // misses: maxMissed goes from 8 - ceil(0.5*8) = 4 to 16 - ceil(0.5*16) = 8. + newSLA := oldSLA + newSLA.SignedBlocksWindow = 16 + msgSrv := providerkeeper.NewMsgServerImpl(&providerKeeper) + _, err := msgSrv.UpdateInfractionParams(ctx, &types.MsgUpdateInfractionParams{ + Authority: providerKeeper.GetAuthority(), + InfractionParameters: newSLA, + }) + require.NoError(t, err) + + // A window computed under the superseded SLA is still accepted, and is + // judged by the threshold it echoes: 6 missed of 8 exceeds the superseded + // maxMissed of 4, while the live maxMissed of 8 would have rejected it. So + // this asserts both halves -- acceptance of the superseded params, and that + // the packet's own echoed values drive the threshold. + inFlight := vaastypes.NewEvidencePacketData( + sdk.ConsAddress(consAddr), 93, []byte{0x3F}, 8, 8, math.LegacyMustNewDecFromStr("0.5"), + ) + require.NoError(t, providerKeeper.HandleConsumerEvidencePacket(ctx, consumerId, inFlight)) + has, err := providerKeeper.PendingDowntimeSlashes.Has(ctx, collections.Join3(consumerId, consAddr.Bytes(), inFlight.WindowEndHeight)) + require.NoError(t, err) + require.True(t, has, "evidence echoing the superseded SLA must still queue a slash") + + // A disjoint window computed under the new SLA is accepted as well: 9 + // missed of 16 exceeds the new maxMissed of 8. + underNewSLA := vaastypes.NewEvidencePacketData( + sdk.ConsAddress(consAddr), 201, []byte{0xFF, 0x01}, 16, 16, math.LegacyMustNewDecFromStr("0.5"), + ) + require.NoError(t, providerKeeper.HandleConsumerEvidencePacket(ctx, consumerId, underNewSLA)) + has, err = providerKeeper.PendingDowntimeSlashes.Has(ctx, collections.Join3(consumerId, consAddr.Bytes(), underNewSLA.WindowEndHeight)) + require.NoError(t, err) + require.True(t, has, "evidence echoing the live SLA must queue a slash") + + // Once the tolerance horizon has elapsed the superseded SLA is no longer + // accepted: nothing computed under it can still be inside its challenge + // window, so a consumer echoing it is stating something impossible. + horizon := newSLA.DowntimeEvidenceMaxAge + newSLA.DowntimeChallengeWindow + stale := ctx.WithBlockTime(ctx.BlockTime().Add(horizon + time.Second)) + late := vaastypes.NewEvidencePacketData( + sdk.ConsAddress(consAddr), 301, []byte{0x3F}, 8, 8, math.LegacyMustNewDecFromStr("0.5"), + ) + err = providerKeeper.HandleConsumerEvidencePacket(stale, consumerId, late) + require.ErrorContains(t, err, "unacceptable downtime params") +} + func TestEvidencePacketDataJSONRoundTrip(t *testing.T) { addr := sdk.ConsAddress([]byte{0x01, 0x02, 0x03, 0x04, 0x05}) packet := vaastypes.NewEvidencePacketData(addr, 42, []byte{0x01}, 1, 600, math.LegacyMustNewDecFromStr("0.5")) diff --git a/x/vaas/provider/keeper/grpc_query.go b/x/vaas/provider/keeper/grpc_query.go index 5eb420ce..912ce640 100644 --- a/x/vaas/provider/keeper/grpc_query.go +++ b/x/vaas/provider/keeper/grpc_query.go @@ -188,9 +188,11 @@ func (k Keeper) QueryParams(goCtx context.Context, req *types.QueryParamsRequest } ctx := sdk.UnwrapSDKContext(goCtx) - params := k.GetParams(ctx) - return &types.QueryParamsResponse{Params: params}, nil + return &types.QueryParamsResponse{ + Params: k.GetParams(ctx), + InfractionParameters: k.GetInfractionParams(ctx), + }, nil } func (k Keeper) QueryConsumerValidators(goCtx context.Context, req *types.QueryConsumerValidatorsRequest) (*types.QueryConsumerValidatorsResponse, error) { diff --git a/x/vaas/provider/keeper/grpc_query_test.go b/x/vaas/provider/keeper/grpc_query_test.go index 99d7e2f5..500feb25 100644 --- a/x/vaas/provider/keeper/grpc_query_test.go +++ b/x/vaas/provider/keeper/grpc_query_test.go @@ -432,3 +432,25 @@ func TestQueryWithheldFeeRecords_UnknownConsumer(t *testing.T) { require.Error(t, err) require.Equal(t, codes.InvalidArgument, status.Code(err)) } + +// TestQueryParamsIncludesInfractionParameters verifies that QueryParams +// reports the infraction parameters alongside Params. They are stored as their +// own state item and updated by their own governance message, so a proposer +// needs a way to read the values in force. +func TestQueryParamsIncludesInfractionParameters(t *testing.T) { + k, ctx, ctrl, _ := testkeeper.GetProviderKeeperAndCtx(t, testkeeper.NewInMemKeeperParams(t)) + defer ctrl.Finish() + + params := providertypes.DefaultParams() + params.BlocksPerEpoch = 900 + k.SetParams(ctx, params) + + infractionParams := providertypes.DefaultInfractionParameters() + infractionParams.SignedBlocksWindow = 1200 + k.SetInfractionParams(ctx, infractionParams) + + resp, err := k.QueryParams(ctx, &providertypes.QueryParamsRequest{}) + require.NoError(t, err) + require.Equal(t, params, resp.Params) + require.Equal(t, infractionParams, resp.InfractionParameters) +} diff --git a/x/vaas/provider/keeper/msg_server.go b/x/vaas/provider/keeper/msg_server.go index 6a02d07c..50e5d1d0 100644 --- a/x/vaas/provider/keeper/msg_server.go +++ b/x/vaas/provider/keeper/msg_server.go @@ -49,6 +49,16 @@ func (k msgServer) UpdateParams(goCtx context.Context, msg *types.MsgUpdateParam ctx := sdk.UnwrapSDKContext(goCtx) + // TrustingPeriodFraction is one half of a constraint it shares with the + // separately-stored infraction parameters: the oldest challengeable header + // must stay light-client verifiable through its challenge window. Lowering + // the fraction shrinks that budget, so the stored infraction parameters are + // re-checked against the incoming fraction here, exactly as genesis checks + // the pair together. + if err := types.ValidateInfractionParamsAgainst(k.GetInfractionParams(ctx), msg.Params.TrustingPeriodFraction); err != nil { + return nil, err + } + // Capture the current floor before applying the new params so we only walk // the overrides when the fees_per_block floor actually rises. oldFloor := k.GetFeesPerBlock(ctx).Amount @@ -66,6 +76,47 @@ func (k msgServer) UpdateParams(goCtx context.Context, msg *types.MsgUpdateParam return &types.MsgUpdateParamsResponse{}, nil } +// UpdateInfractionParams replaces the provider's infraction parameters: the +// slash/jail policy for consumer double-signs and downtime, the downtime SLA +// window, the challenge window and the evidence max age. They are stored +// outside Params, so they have their own governance message; both handlers +// enforce the constraint the two halves share, each against the stored other +// half. Widening the challengeable interval is additionally checked against the +// consumer clients already adopted, which no later discovery would repair (see +// ValidateInfractionParamsAgainstAdoptedClients). +// +// Changing signed_blocks_window or min_signed_per_window redefines the SLA +// consumers compute their bitmaps against. SetInfractionParams records the +// superseded pair in PreviousDowntimeParams, so evidence already in flight -- +// computed and echoed under the old values -- keeps being accepted for +// DowntimeEvidenceMaxAge + DowntimeChallengeWindow after the change (see +// AcceptableDowntimeParams), judged against the threshold it was computed +// under. Consumers pick the new values up from the next VSC packet and +// activate them at their next window boundary. +func (k msgServer) UpdateInfractionParams(goCtx context.Context, msg *types.MsgUpdateInfractionParams) (*types.MsgUpdateInfractionParamsResponse, error) { + if k.GetAuthority() != msg.Authority { + return nil, errorsmod.Wrapf(govtypes.ErrInvalidSigner, "invalid authority; expected %s, got %s", k.authority, msg.Authority) + } + + if err := msg.InfractionParameters.Validate(); err != nil { + return nil, err + } + + ctx := sdk.UnwrapSDKContext(goCtx) + + if err := types.ValidateInfractionParamsAgainst(msg.InfractionParameters, k.GetParams(ctx).TrustingPeriodFraction); err != nil { + return nil, err + } + + if err := k.ValidateInfractionParamsAgainstAdoptedClients(ctx, msg.InfractionParameters); err != nil { + return nil, err + } + + k.Keeper.SetInfractionParams(ctx, msg.InfractionParameters) + + return &types.MsgUpdateInfractionParamsResponse{}, nil +} + // AssignConsumerKey defines a method to assign a consensus key on a consumer chain // for a given validator on the provider func (k msgServer) AssignConsumerKey(goCtx context.Context, msg *types.MsgAssignConsumerKey) (*types.MsgAssignConsumerKeyResponse, error) { diff --git a/x/vaas/provider/keeper/msg_server_test.go b/x/vaas/provider/keeper/msg_server_test.go index ea3b9c5e..82cef10c 100644 --- a/x/vaas/provider/keeper/msg_server_test.go +++ b/x/vaas/provider/keeper/msg_server_test.go @@ -1,6 +1,7 @@ package keeper_test import ( + "fmt" "strconv" "sync" "testing" @@ -607,6 +608,9 @@ func TestUpdateParams_ReconcilesFeesPerBlockOverrides(t *testing.T) { k, ctx, ctrl, _ := testkeeper.GetProviderKeeperAndCtx(t, params) defer ctrl.Finish() k.SetParams(ctx, providertypes.DefaultParams()) // global default = 1000 + // UpdateParams re-checks the stored infraction params against the incoming + // trusting-period fraction, so they must be seeded as InitGenesis does. + k.SetInfractionParams(ctx, providertypes.DefaultInfractionParameters()) // Three overrides, all above the current floor (1000). below := k.FetchAndIncrementConsumerId(ctx) // 1500: below the new floor -> dropped @@ -652,6 +656,283 @@ func TestUpdateParams_ReconcilesFeesPerBlockOverrides(t *testing.T) { require.Equal(t, math.NewInt(2500), amtAbove) } +// TestUpdateParamsRejectsTrustingFractionStrandingInfractionParams verifies the +// other half of the cross-parameter constraint: lowering +// trusting_period_fraction far enough that the stored evidence-age plus +// challenge window no longer fits inside the derived trusting period is +// rejected, so the pair genesis validates together cannot be broken one message +// at a time. +func TestUpdateParamsRejectsTrustingFractionStrandingInfractionParams(t *testing.T) { + k, ctx, ctrl, _ := testkeeper.GetProviderKeeperAndCtx(t, testkeeper.NewInMemKeeperParams(t)) + defer ctrl.Finish() + k.SetParams(ctx, providertypes.DefaultParams()) + k.SetInfractionParams(ctx, providertypes.DefaultInfractionParameters()) + + msgSrv := providerkeeper.NewMsgServerImpl(&k) + + // Defaults leave 240h of evidence-age + challenge window against a + // 0.66 * 480h = 316.8h trusting period. At 0.5 the trusting period is + // exactly 240h, which the strict inequality rejects. + stranding := providertypes.DefaultParams() + stranding.TrustingPeriodFraction = "0.5" + _, err := msgSrv.UpdateParams(ctx, &providertypes.MsgUpdateParams{ + Authority: k.GetAuthority(), + Params: stranding, + }) + require.ErrorContains(t, err, "must be below the default trusting period") + require.Equal(t, providertypes.DefaultTrustingPeriodFraction, k.GetParams(ctx).TrustingPeriodFraction, + "a rejected update must not have been applied") + + // A fraction that still covers the stored horizon is accepted. + covering := providertypes.DefaultParams() + covering.TrustingPeriodFraction = "0.9" + _, err = msgSrv.UpdateParams(ctx, &providertypes.MsgUpdateParams{ + Authority: k.GetAuthority(), + Params: covering, + }) + require.NoError(t, err) + require.Equal(t, "0.9", k.GetParams(ctx).TrustingPeriodFraction) +} + +// TestUpdateInfractionParams covers the governance path for the infraction +// parameters: authority gating, full validation (including the cross-parameter +// constraint against the stored trusting-period fraction), and that an accepted +// update replaces the stored set. +func TestUpdateInfractionParams(t *testing.T) { + invalidPair := providertypes.DefaultInfractionParameters() + invalidPair.DowntimeEvidenceMaxAge = invalidPair.DowntimeChallengeWindow + time.Hour + + overTrusting := providertypes.DefaultInfractionParameters() + // 200h + 200h = 400h against the default 0.66 * 480h = 316.8h trusting + // period: individually valid, jointly unverifiable. + overTrusting.DowntimeChallengeWindow = 200 * time.Hour + overTrusting.DowntimeEvidenceMaxAge = 200 * time.Hour + + noDoubleSign := providertypes.DefaultInfractionParameters() + noDoubleSign.DoubleSign = nil + + responsive := providertypes.DefaultInfractionParameters() + responsive.Downtime = &providertypes.SlashJailParameters{ + JailDuration: 0, + SlashFraction: math.LegacyMustNewDecFromStr("0.001"), + Tombstone: false, + } + responsive.SignedBlocksWindow = 1200 + responsive.MinSignedPerWindow = math.LegacyMustNewDecFromStr("0.75") + responsive.DowntimeGracePeriod = 0 + + cases := []struct { + name string + authority func(k providerkeeper.Keeper) string + params providertypes.InfractionParameters + wantErr string + }{ + { + name: "non-authority signer is rejected", + authority: func(providerkeeper.Keeper) string { return authtypes.NewModuleAddress("nobody").String() }, + params: responsive, + wantErr: "invalid authority", + }, + { + name: "evidence max age above the challenge window is rejected", + authority: providerkeeper.Keeper.GetAuthority, + params: invalidPair, + wantErr: "must not exceed downtime_challenge_window", + }, + { + name: "horizon exceeding the trusting period is rejected", + authority: providerkeeper.Keeper.GetAuthority, + params: overTrusting, + wantErr: "must be below the default trusting period", + }, + { + name: "missing double-sign parameters are rejected", + authority: providerkeeper.Keeper.GetAuthority, + params: noDoubleSign, + wantErr: "double_sign infraction parameters must be set", + }, + { + name: "a valid tightening is applied", + authority: providerkeeper.Keeper.GetAuthority, + params: responsive, + }, + } + + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + k, ctx, ctrl, _ := testkeeper.GetProviderKeeperAndCtx(t, testkeeper.NewInMemKeeperParams(t)) + defer ctrl.Finish() + k.SetParams(ctx, providertypes.DefaultParams()) + k.SetInfractionParams(ctx, providertypes.DefaultInfractionParameters()) + + msgSrv := providerkeeper.NewMsgServerImpl(&k) + _, err := msgSrv.UpdateInfractionParams(ctx, &providertypes.MsgUpdateInfractionParams{ + Authority: tc.authority(k), + InfractionParameters: tc.params, + }) + + if tc.wantErr != "" { + require.ErrorContains(t, err, tc.wantErr) + require.Equal(t, providertypes.DefaultInfractionParameters(), k.GetInfractionParams(ctx), + "a rejected update must not have been applied") + return + } + require.NoError(t, err) + require.Equal(t, tc.params, k.GetInfractionParams(ctx)) + }) + } +} + +// TestUpdateInfractionParamsAgainstAdoptedClients verifies that widening the +// challengeable interval (evidence max age + challenge window) past the trusting +// period of an already-adopted consumer client is rejected -- such an interval +// would leave the oldest challengeable header unverifiable, so pending slashes +// on that consumer would execute undefended -- while a widening that still fits +// every adopted client, and any narrowing, are accepted. The narrowing case is +// checked with a client too short even for the current interval: a chain in that +// state must still be able to correct itself. +func TestUpdateInfractionParamsAgainstAdoptedClients(t *testing.T) { + // The stored starting point: 72h + 168h = 240h. + current := providertypes.DefaultInfractionParameters() + + widenPast := providertypes.DefaultInfractionParameters() + widenPast.DowntimeEvidenceMaxAge = 100 * time.Hour + widenPast.DowntimeChallengeWindow = 160 * time.Hour // 260h + + widenWithin := providertypes.DefaultInfractionParameters() + widenWithin.DowntimeEvidenceMaxAge = 85 * time.Hour + widenWithin.DowntimeChallengeWindow = 160 * time.Hour // 245h + + narrow := providertypes.DefaultInfractionParameters() + narrow.DowntimeEvidenceMaxAge = 50 * time.Hour + narrow.DowntimeChallengeWindow = 100 * time.Hour // 150h + + cases := []struct { + name string + trustingPeriods map[uint64]time.Duration + params providertypes.InfractionParameters + wantErr string + }{ + { + name: "widening past the shortest adopted client is rejected", + trustingPeriods: map[uint64]time.Duration{0: 300 * time.Hour, 1: 250 * time.Hour}, + params: widenPast, + wantErr: "must be below the trusting period (250h0m0s) of client 07-tendermint-1, already adopted for consumer 1", + }, + { + name: "widening that still fits every adopted client is accepted", + trustingPeriods: map[uint64]time.Duration{0: 300 * time.Hour, 1: 250 * time.Hour}, + params: widenWithin, + }, + { + name: "widening is unconstrained when no client is adopted yet", + trustingPeriods: nil, + params: widenPast, + }, + { + // 240h down to 150h, against a client that trusts only 100h: still + // wider than that client can support, but strictly better than what + // it replaces, so it must go through. A chain that reaches this state + // has to be able to walk itself back out of it. + name: "narrowing is allowed even when it stays above an adopted client's trusting period", + trustingPeriods: map[uint64]time.Duration{0: 100 * time.Hour}, + params: narrow, + }, + } + + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + k, ctx, ctrl, mocks := testkeeper.GetProviderKeeperAndCtx(t, testkeeper.NewInMemKeeperParams(t)) + defer ctrl.Finish() + k.SetParams(ctx, providertypes.DefaultParams()) + k.SetInfractionParams(ctx, current) + + for consumerId, trustingPeriod := range tc.trustingPeriods { + clientId := fmt.Sprintf("07-tendermint-%d", consumerId) + k.SetConsumerClientId(ctx, consumerId, clientId) + mocks.MockClientKeeper.EXPECT().GetClientState(ctx, clientId). + Return(&ibctmtypes.ClientState{TrustingPeriod: trustingPeriod}, true).AnyTimes() + } + + msgSrv := providerkeeper.NewMsgServerImpl(&k) + _, err := msgSrv.UpdateInfractionParams(ctx, &providertypes.MsgUpdateInfractionParams{ + Authority: k.GetAuthority(), + InfractionParameters: tc.params, + }) + + if tc.wantErr != "" { + require.ErrorContains(t, err, tc.wantErr) + require.Equal(t, current, k.GetInfractionParams(ctx), + "a rejected update must not have been applied") + return + } + require.NoError(t, err) + require.Equal(t, tc.params, k.GetInfractionParams(ctx)) + }) + } +} + +// TestUpdateInfractionParamsRecordsPreviousDowntimeParams verifies that the +// governance path drives the change-tolerance machinery: a change to the +// downtime SLA records the superseded pair in PreviousDowntimeParams stamped +// with the block time of the change, while a change that leaves the SLA alone +// records nothing. Without a runtime caller of SetInfractionParams neither +// PreviousDowntimeParams nor AcceptableDowntimeParams could ever fire outside +// genesis. +func TestUpdateInfractionParamsRecordsPreviousDowntimeParams(t *testing.T) { + k, ctx, ctrl, _ := testkeeper.GetProviderKeeperAndCtx(t, testkeeper.NewInMemKeeperParams(t)) + defer ctrl.Finish() + k.SetParams(ctx, providertypes.DefaultParams()) + k.SetInfractionParams(ctx, providertypes.DefaultInfractionParameters()) + beforeSLA := k.CurrentDowntimeParams(ctx) + + msgSrv := providerkeeper.NewMsgServerImpl(&k) + + // A change that leaves signed_blocks_window / min_signed_per_window alone + // does not supersede any SLA, so nothing is recorded. + slashOnly := providertypes.DefaultInfractionParameters() + slashOnly.Downtime.SlashFraction = math.LegacyMustNewDecFromStr("0.002") + _, err := msgSrv.UpdateInfractionParams(ctx, &providertypes.MsgUpdateInfractionParams{ + Authority: k.GetAuthority(), + InfractionParameters: slashOnly, + }) + require.NoError(t, err) + has, err := k.PreviousDowntimeParams.Has(ctx) + require.NoError(t, err) + require.False(t, has, "a non-SLA change must not record a previous downtime params entry") + + // An SLA change records the superseded pair, stamped with the block time of + // the change -- the instant AcceptableDowntimeParams measures its tolerance + // horizon from. + changedAt := ctx.BlockTime().Add(time.Hour) + slaCtx := ctx.WithBlockTime(changedAt) + slaChange := slashOnly + slaChange.SignedBlocksWindow = 1200 + slaChange.MinSignedPerWindow = math.LegacyMustNewDecFromStr("0.75") + _, err = msgSrv.UpdateInfractionParams(slaCtx, &providertypes.MsgUpdateInfractionParams{ + Authority: k.GetAuthority(), + InfractionParameters: slaChange, + }) + require.NoError(t, err) + + previous, err := k.PreviousDowntimeParams.Get(slaCtx) + require.NoError(t, err) + require.Equal(t, beforeSLA, previous.Params) + require.True(t, changedAt.Equal(previous.ChangedAt), "expected %s, got %s", changedAt, previous.ChangedAt) + + // The stored SLA is what consumers now receive in VSC packets and genesis. + require.Equal(t, slaChange.SignedBlocksWindow, k.CurrentDowntimeParams(slaCtx).SignedBlocksWindow) + require.True(t, slaChange.MinSignedPerWindow.Equal(k.CurrentDowntimeParams(slaCtx).MinSignedPerWindow)) + + // Evidence echoing either the superseded or the new SLA is acceptable while + // the tolerance horizon holds; anything else never is. + require.True(t, k.AcceptableDowntimeParams(slaCtx, beforeSLA)) + require.True(t, k.AcceptableDowntimeParams(slaCtx, k.CurrentDowntimeParams(slaCtx))) + + horizon := slaChange.DowntimeEvidenceMaxAge + slaChange.DowntimeChallengeWindow + require.False(t, k.AcceptableDowntimeParams(slaCtx.WithBlockTime(changedAt.Add(horizon+time.Second)), beforeSLA)) +} + func TestRemoveConsumerGovAuth(t *testing.T) { providerKeeper, ctx, ctrl, mocks := testkeeper.GetProviderKeeperAndCtx(t, testkeeper.NewInMemKeeperParams(t)) defer ctrl.Finish() diff --git a/x/vaas/provider/keeper/params.go b/x/vaas/provider/keeper/params.go index 7be56a82..2b20d090 100644 --- a/x/vaas/provider/keeper/params.go +++ b/x/vaas/provider/keeper/params.go @@ -186,6 +186,63 @@ func (k Keeper) SetInfractionParams(ctx context.Context, params types.Infraction } } +// challengeableInterval is how far back a challenge may have to reach: evidence +// is accepted while its window end is within DowntimeEvidenceMaxAge, and the +// slash it queues stays challengeable for DowntimeChallengeWindow after that. +// The oldest header a challenge can need is therefore this far in the past, and +// verifying it requires the consumer's client to still trust a consensus state +// that old. +func challengeableInterval(ip types.InfractionParameters) time.Duration { + return ip.DowntimeEvidenceMaxAge + ip.DowntimeChallengeWindow +} + +// ValidateInfractionParamsAgainstAdoptedClients rejects infraction parameters +// that widen the challengeable interval past the trusting period of a consumer +// client the provider has already adopted. A downtime challenge is verified +// against that client, so an interval wider than its trusting period leaves the +// oldest challengeable header unverifiable and the accused validator's slash +// executing undefended. The provider does not re-adopt a client to repair this, +// so the only place to catch it is before the parameters change. +// +// Only widening is checked. Narrowing the interval, or leaving it unchanged, can +// only move it further inside every client's trusting period, and must stay +// unconditionally allowed -- otherwise a chain already holding a client too +// short for its current parameters could never be brought back into line. +// +// Every consumer with an adopted client is checked, not only the launched ones: +// a paused consumer keeps its client and accepts evidence again once resumed. +// Clients whose state is missing or is not a Tendermint client are skipped, +// there being no trusting period to compare against. +// +// This generalises types.ValidateInfractionParamsAgainst, which bounds the same +// interval by the trusting period derived from the default consumer unbonding +// period: that bound constrains the parameters in the abstract, this one +// constrains them against the clients that actually exist. +func (k Keeper) ValidateInfractionParamsAgainstAdoptedClients(ctx sdk.Context, ip types.InfractionParameters) error { + proposed := challengeableInterval(ip) + if proposed <= challengeableInterval(k.GetInfractionParams(ctx)) { + return nil + } + + return k.ConsumerClients.Walk(ctx, nil, func(consumerId uint64, clientId string) (bool, error) { + clientState, found := k.clientKeeper.GetClientState(ctx, clientId) + if !found { + return false, nil + } + tmClientState, ok := clientState.(*ibctmtypes.ClientState) + if !ok { + return false, nil + } + if proposed >= tmClientState.TrustingPeriod { + return true, fmt.Errorf( + "downtime_evidence_max_age + downtime_challenge_window (%s) must be below the trusting period (%s) of client %s, already adopted for consumer %d", + proposed, tmClientState.TrustingPeriod, clientId, consumerId, + ) + } + return false, nil + }) +} + // CurrentDowntimeParams returns the provider's current downtime detection // parameters, derived from InfractionParams, for distribution to consumers // via genesis and VSC packets. diff --git a/x/vaas/provider/keeper/window_end_timestamp_test.go b/x/vaas/provider/keeper/window_end_timestamp_test.go index 250c2798..1c5621b1 100644 --- a/x/vaas/provider/keeper/window_end_timestamp_test.go +++ b/x/vaas/provider/keeper/window_end_timestamp_test.go @@ -31,7 +31,7 @@ func newFakeClientStoreProvider(params testkeeper.InMemKeeperParams) ibcclientty return ibcclienttypes.NewStoreProvider(runtime.NewKVStoreService(params.StoreKey)) } -func TestWindowEndTimestampSelectsSmallestHeightAtOrAboveWindowEnd(t *testing.T) { +func TestWindowEndTimestampSelectsExactHeightWhenStored(t *testing.T) { keeperParams := testkeeper.NewInMemKeeperParams(t) providerKeeper, ctx, ctrl, mocks := testkeeper.GetProviderKeeperAndCtx(t, keeperParams) defer ctrl.Finish() @@ -41,8 +41,9 @@ func TestWindowEndTimestampSelectsSmallestHeightAtOrAboveWindowEnd(t *testing.T) mocks.MockClientKeeper.EXPECT().GetStoreProvider().Return(storeProvider).AnyTimes() clientStore := storeProvider.ClientStore(ctx, clientId) - // Heights below, at, and above windowEnd=100; the smallest at-or-above - // (100 itself) must be chosen over 120 and 150. + // Heights below, at, and above windowEnd=100. A state at exactly windowEnd + // is both the highest at-or-below and the smallest at-or-above, so it is + // the anchor -- 50 below it and 120/150 above it are all ignored. for _, h := range []uint64{50, 150, 120, 100} { ibctmtypes.SetIterationKey(clientStore, ibcclienttypes.NewHeight(0, h)) } @@ -90,6 +91,65 @@ func TestWindowEndTimestampErrorsOnEmptyClientStore(t *testing.T) { require.Error(t, err) } +func TestWindowEndTimestampRejectsWhenWindowEndPredatesRetainedStates(t *testing.T) { + keeperParams := testkeeper.NewInMemKeeperParams(t) + providerKeeper, ctx, ctrl, mocks := testkeeper.GetProviderKeeperAndCtx(t, keeperParams) + defer ctrl.Finish() + + const clientId = "07-tendermint-0" + storeProvider := newFakeClientStoreProvider(keeperParams) + mocks.MockClientKeeper.EXPECT().GetStoreProvider().Return(storeProvider).AnyTimes() + + clientStore := storeProvider.ClientStore(ctx, clientId) + // windowEnd=100, but every retained consensus state sits far above it: the + // states at or below 100 have been pruned (or the client is sparse there), + // so nothing supplies a verified lower bound on the height-100 time. Falling + // back to the smallest state >= 100 (here 5000) would place the window end + // far later than it really was, understating the evidence's age and letting + // genuinely-stale evidence pass the age check. The anchor is rejected + // instead. + for _, h := range []uint64{5000, 6000} { + ibctmtypes.SetIterationKey(clientStore, ibcclienttypes.NewHeight(0, h)) + } + + // No GetClientConsensusState expectation: the rejection must happen before + // any consensus-state timestamp is read. + _, err := providerKeeper.WindowEndTimestampForTest(ctx, clientId, 100) + require.Error(t, err) + require.ErrorContains(t, err, "retained consensus states") +} + +func TestWindowEndTimestampAnchorsToHighestStateAtOrBelowWindowEnd(t *testing.T) { + keeperParams := testkeeper.NewInMemKeeperParams(t) + providerKeeper, ctx, ctrl, mocks := testkeeper.GetProviderKeeperAndCtx(t, keeperParams) + defer ctrl.Finish() + + const clientId = "07-tendermint-0" + storeProvider := newFakeClientStoreProvider(keeperParams) + mocks.MockClientKeeper.EXPECT().GetStoreProvider().Return(storeProvider).AnyTimes() + + clientStore := storeProvider.ClientStore(ctx, clientId) + // windowEnd=100 sits between stored states. The state at 120 proves the + // chain reached the window end, but the timestamp comes from 90 -- the + // highest state at or below windowEnd, hence a verified lower bound on the + // true height-100 time. Anchoring to 120 instead would place the window end + // later than it really was and understate the evidence's age. 40 and 90 are + // both at or below windowEnd; the higher one wins as the tighter bound. + for _, h := range []uint64{40, 90, 120} { + ibctmtypes.SetIterationKey(clientStore, ibcclienttypes.NewHeight(0, h)) + } + + wantHeight := ibcclienttypes.NewHeight(0, 90) + wantTime := time.Date(2025, 2, 1, 0, 0, 0, 0, time.UTC) + mocks.MockClientKeeper.EXPECT(). + GetClientConsensusState(ctx, clientId, wantHeight). + Return(&ibctmtypes.ConsensusState{Timestamp: wantTime}, true) + + got, err := providerKeeper.WindowEndTimestampForTest(ctx, clientId, 100) + require.NoError(t, err) + require.True(t, wantTime.Equal(got), "expected %s, got %s", wantTime, got) +} + func TestWindowEndTimestampIgnoresRevisionNumberSelectingByHeightOnly(t *testing.T) { keeperParams := testkeeper.NewInMemKeeperParams(t) providerKeeper, ctx, ctrl, mocks := testkeeper.GetProviderKeeperAndCtx(t, keeperParams) diff --git a/x/vaas/provider/types/codec.go b/x/vaas/provider/types/codec.go index 581d90ed..2c8337ab 100644 --- a/x/vaas/provider/types/codec.go +++ b/x/vaas/provider/types/codec.go @@ -22,6 +22,7 @@ func RegisterInterfaces(registry codectypes.InterfaceRegistry) { &MsgUpdateConsumer{}, &MsgRemoveConsumer{}, &MsgUpdateParams{}, + &MsgUpdateInfractionParams{}, &MsgSubmitConsumerMisbehaviour{}, &MsgSubmitConsumerDoubleVoting{}, &MsgSetConsumerFeesPerBlock{}, diff --git a/x/vaas/provider/types/msg.go b/x/vaas/provider/types/msg.go index 4bb80347..1715802b 100644 --- a/x/vaas/provider/types/msg.go +++ b/x/vaas/provider/types/msg.go @@ -306,6 +306,20 @@ func (msg MsgRemoveConsumer) ValidateBasic() error { return nil } +// ValidateBasic enforces that the authority parses as bech32 and that the +// replacement infraction parameters are internally consistent. The constraint +// they share with Params.TrustingPeriodFraction needs stored state, so it is +// enforced in the handler instead (see ValidateInfractionParamsAgainst). +func (msg MsgUpdateInfractionParams) ValidateBasic() error { + if _, err := sdk.AccAddressFromBech32(msg.Authority); err != nil { + return errorsmod.Wrapf(sdkerrors.ErrInvalidAddress, "invalid authority address: %s", err) + } + if err := msg.InfractionParameters.Validate(); err != nil { + return errorsmod.Wrap(sdkerrors.ErrInvalidRequest, err.Error()) + } + return nil +} + // ValidateBasic enforces: // - authority parses as bech32 // - amount is empty (clear semantics) OR parses as a positive math.Int diff --git a/x/vaas/provider/types/msg_test.go b/x/vaas/provider/types/msg_test.go index 96f7eed3..eca462a6 100644 --- a/x/vaas/provider/types/msg_test.go +++ b/x/vaas/provider/types/msg_test.go @@ -958,3 +958,60 @@ func TestMsgResumeConsumer_ValidateBasic(t *testing.T) { }) } } + +func TestMsgUpdateInfractionParams_ValidateBasic(t *testing.T) { + validAuthority := authtypes.NewModuleAddress(govtypes.ModuleName).String() + + noDowntime := types.DefaultInfractionParameters() + noDowntime.Downtime = nil + + zeroWindow := types.DefaultInfractionParameters() + zeroWindow.SignedBlocksWindow = 0 + + minSignedAtOne := types.DefaultInfractionParameters() + minSignedAtOne.MinSignedPerWindow = math.LegacyOneDec() + + ageAboveChallenge := types.DefaultInfractionParameters() + ageAboveChallenge.DowntimeEvidenceMaxAge = ageAboveChallenge.DowntimeChallengeWindow + time.Hour + + tests := []struct { + name string + msg types.MsgUpdateInfractionParams + wantErr bool + }{ + {"valid", types.MsgUpdateInfractionParams{ + Authority: validAuthority, + InfractionParameters: types.DefaultInfractionParameters(), + }, false}, + {"invalid authority", types.MsgUpdateInfractionParams{ + Authority: "not-bech32", + InfractionParameters: types.DefaultInfractionParameters(), + }, true}, + {"missing downtime parameters", types.MsgUpdateInfractionParams{ + Authority: validAuthority, + InfractionParameters: noDowntime, + }, true}, + {"zero signed blocks window", types.MsgUpdateInfractionParams{ + Authority: validAuthority, + InfractionParameters: zeroWindow, + }, true}, + {"min signed per window at one", types.MsgUpdateInfractionParams{ + Authority: validAuthority, + InfractionParameters: minSignedAtOne, + }, true}, + {"evidence max age above challenge window", types.MsgUpdateInfractionParams{ + Authority: validAuthority, + InfractionParameters: ageAboveChallenge, + }, true}, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + err := tc.msg.ValidateBasic() + if tc.wantErr { + require.Error(t, err) + } else { + require.NoError(t, err) + } + }) + } +} diff --git a/x/vaas/provider/types/params.go b/x/vaas/provider/types/params.go index ccea34e7..a9a1c8ec 100644 --- a/x/vaas/provider/types/params.go +++ b/x/vaas/provider/types/params.go @@ -203,7 +203,14 @@ func (ip InfractionParameters) Validate() error { // challenge window: evidenceMaxAge + challengeWindow < trustingFraction * // defaultConsumerUnbonding. Called wherever incoming infraction params are // validated together with Params, since InfractionParameters is stored -// separately from Params. +// separately from Params -- at genesis and from both governance handlers, each +// checking the incoming half against the stored other half. +// +// The bound is the default consumer unbonding period, not the trusting period +// of any client already adopted for a consumer. Consumer creation is +// permissionless and its unbonding period only has an upper bound, so binding +// a provider-wide policy change to the shortest-lived client in existence +// would let one consumer veto it. func ValidateInfractionParamsAgainst(ip InfractionParameters, trustingPeriodFraction string) error { frac, err := math.LegacyNewDecFromStr(trustingPeriodFraction) if err != nil { diff --git a/x/vaas/provider/types/provider.pb.go b/x/vaas/provider/types/provider.pb.go index aa28df58..23e5a918 100644 --- a/x/vaas/provider/types/provider.pb.go +++ b/x/vaas/provider/types/provider.pb.go @@ -957,6 +957,12 @@ type PendingDowntimeSlash struct { // slash amount in bond denom, resolved at receipt (P * M / C) SlashTokens cosmossdk_io_math.Int `protobuf:"bytes,7,opt,name=slash_tokens,json=slashTokens,proto3,customtype=cosmossdk.io/math.Int" json:"slash_tokens"` MaturesAt time.Time `protobuf:"bytes,8,opt,name=matures_at,json=maturesAt,proto3,stdtime" json:"matures_at"` + // consumer_cons_addr is the reporting validator's consensus address on the + // consumer chain, captured at acceptance. A challenge names this address, + // and provider_cons_addr above is derived from it through the key-assignment + // mapping; storing it lets the challenge find this slash even after that + // mapping is pruned or the validator rotates its consumer key. + ConsumerConsAddr []byte `protobuf:"bytes,9,opt,name=consumer_cons_addr,json=consumerConsAddr,proto3" json:"consumer_cons_addr,omitempty"` } func (m *PendingDowntimeSlash) Reset() { *m = PendingDowntimeSlash{} } @@ -1041,6 +1047,13 @@ func (m *PendingDowntimeSlash) GetMaturesAt() time.Time { return time.Time{} } +func (m *PendingDowntimeSlash) GetConsumerConsAddr() []byte { + if m != nil { + return m.ConsumerConsAddr + } + return nil +} + // AcceptedDowntimeWindow records one downtime-detection window whose evidence // has been accepted for a (consumer, validator) pair; the keeper keys it by // (consumer_id, provider_cons_addr, window_end_height), so only the window's @@ -1308,124 +1321,125 @@ func init() { func init() { proto.RegisterFile("vaas/provider/v1/provider.proto", fileDescriptor_6404dd5d21545279) } var fileDescriptor_6404dd5d21545279 = []byte{ - // 1864 bytes of a gzipped FileDescriptorProto + // 1878 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x58, 0xcd, 0x6f, 0x23, 0x49, 0x15, 0x4f, 0xc7, 0x9e, 0x6c, 0x52, 0x76, 0x06, 0xa7, 0x26, 0x1f, 0x4e, 0x76, 0x36, 0xc9, 0x1a, 0x2d, 0x8a, 0x76, 0xd9, 0xee, 0xc9, 0x20, 0x16, 0x04, 0x87, 0x91, 0x63, 0x7b, 0x26, 0x66, 0x32, 0x59, 0xd3, 0xf6, 0x30, 0xd2, 0x0a, 0x68, 0x95, 0xbb, 0xdf, 0xd8, 0xb5, 0xe9, 0xee, 0x6a, 0x75, - 0x95, 0x9d, 0x98, 0x23, 0xe2, 0xc0, 0x71, 0x11, 0x1c, 0xb8, 0x20, 0x21, 0x71, 0xe1, 0xc8, 0x01, - 0x71, 0xe4, 0xbc, 0xc7, 0x15, 0x5c, 0x10, 0x42, 0xbb, 0xab, 0x19, 0x24, 0xfe, 0x0d, 0x54, 0x1f, - 0xdd, 0xf6, 0x24, 0x19, 0x6d, 0x2c, 0xb8, 0x58, 0xd5, 0xef, 0xbd, 0xdf, 0xab, 0x57, 0xef, 0xbd, - 0x7a, 0xef, 0x95, 0xd1, 0xde, 0x98, 0x10, 0xee, 0x24, 0x29, 0x1b, 0xd3, 0x00, 0x52, 0x67, 0x7c, - 0x98, 0xaf, 0xed, 0x24, 0x65, 0x82, 0xe1, 0x8a, 0x14, 0xb0, 0x73, 0xe2, 0xf8, 0x70, 0x67, 0x8d, - 0x44, 0x34, 0x66, 0x8e, 0xfa, 0xd5, 0x42, 0x3b, 0xdb, 0x3e, 0xe3, 0x11, 0xe3, 0x9e, 0xfa, 0x72, - 0xf4, 0x87, 0x61, 0xad, 0x0f, 0xd8, 0x80, 0x69, 0xba, 0x5c, 0x19, 0xea, 0xae, 0x96, 0x71, 0xfa, - 0x84, 0x83, 0x33, 0x3e, 0xec, 0x83, 0x20, 0x87, 0x8e, 0xcf, 0x68, 0x6c, 0xf8, 0xdf, 0x30, 0x7c, - 0x90, 0xbb, 0xc6, 0xfe, 0x54, 0x26, 0x23, 0x64, 0x7a, 0x06, 0x8c, 0x0d, 0x42, 0x70, 0xd4, 0x57, - 0x7f, 0xf4, 0xdc, 0x09, 0x46, 0x29, 0x11, 0x94, 0x65, 0x7a, 0xf6, 0x2e, 0xf3, 0x05, 0x8d, 0x80, - 0x0b, 0x12, 0x25, 0x99, 0x00, 0xed, 0xfb, 0x8e, 0xcf, 0x52, 0x70, 0xfc, 0x90, 0x42, 0x2c, 0xa4, - 0x07, 0xf4, 0xca, 0x08, 0x38, 0x52, 0x20, 0xa4, 0x83, 0xa1, 0xd0, 0x64, 0xee, 0x08, 0x88, 0x03, - 0x48, 0x23, 0xaa, 0x85, 0xa7, 0x5f, 0x06, 0x80, 0x95, 0x47, 0xc7, 0x87, 0xce, 0x39, 0x4d, 0x33, - 0x33, 0xef, 0xce, 0x60, 0xfc, 0x74, 0x92, 0x08, 0xe6, 0x9c, 0xc1, 0xc4, 0xb8, 0xa8, 0xf6, 0x45, - 0x01, 0x2d, 0x75, 0x48, 0x4a, 0x22, 0x8e, 0xbf, 0x8b, 0xaa, 0x22, 0x1d, 0x71, 0x41, 0xe3, 0x81, - 0x97, 0x40, 0x4a, 0x59, 0xe0, 0x3d, 0x4f, 0x89, 0x2f, 0x4f, 0x54, 0xb5, 0xf6, 0xad, 0x83, 0x15, - 0x77, 0x33, 0xe3, 0x77, 0x14, 0xfb, 0xa1, 0xe1, 0xe2, 0x0f, 0xd0, 0x56, 0x48, 0xc7, 0x10, 0x03, - 0xe7, 0xde, 0x20, 0x25, 0x3e, 0x4c, 0x81, 0x8b, 0x0a, 0xb8, 0x91, 0xb1, 0x1f, 0x49, 0x6e, 0x8e, - 0xeb, 0xa2, 0x3b, 0xd2, 0x60, 0x4f, 0x3a, 0x86, 0x8d, 0x84, 0xd9, 0xb5, 0x5a, 0xd8, 0xb7, 0x0e, - 0x4a, 0xf7, 0xb7, 0x6d, 0xed, 0x3f, 0x3b, 0xf3, 0x9f, 0xdd, 0x34, 0xfe, 0x3d, 0x5a, 0xfe, 0xf4, - 0xf3, 0xbd, 0x85, 0xdf, 0x7e, 0xb1, 0x67, 0xb9, 0x6b, 0x12, 0xdf, 0xd3, 0x70, 0x6d, 0x14, 0x3e, - 0x40, 0x95, 0x7e, 0xc8, 0xfc, 0x33, 0x2e, 0xd5, 0x79, 0x90, 0x30, 0x7f, 0x58, 0x2d, 0xee, 0x5b, - 0x07, 0x05, 0xf7, 0xb6, 0xa6, 0x77, 0x20, 0x6d, 0x49, 0x2a, 0xf6, 0xd1, 0xc6, 0x73, 0x00, 0x2d, - 0xa7, 0x58, 0x1e, 0x89, 0xd8, 0x28, 0x16, 0xd5, 0x5b, 0xd2, 0xe8, 0xa3, 0x7b, 0x72, 0x97, 0x7f, - 0x7e, 0xbe, 0xb7, 0xa1, 0xf3, 0x81, 0x07, 0x67, 0x36, 0x65, 0x4e, 0x44, 0xc4, 0xd0, 0x6e, 0xc7, - 0xe2, 0x6f, 0x7f, 0x7e, 0x1f, 0x99, 0x64, 0x6b, 0xc7, 0xe2, 0x8f, 0xff, 0xf9, 0xd3, 0xbb, 0x96, - 0x8b, 0xa5, 0xba, 0x0e, 0xa4, 0x47, 0x52, 0x59, 0x5d, 0xe9, 0xc2, 0xdf, 0x44, 0x38, 0xa2, 0xb1, - 0x17, 0x40, 0xc2, 0x38, 0x15, 0x7a, 0x1f, 0x5e, 0x5d, 0xda, 0xb7, 0x0e, 0x8a, 0x6e, 0x25, 0xa2, - 0x71, 0x53, 0x33, 0x14, 0x84, 0xe3, 0x1f, 0x22, 0x1c, 0x91, 0x0b, 0x2f, 0x21, 0x23, 0x0e, 0x5e, - 0x96, 0x4f, 0xd5, 0x37, 0x6e, 0xee, 0x90, 0x4a, 0x44, 0x2e, 0x3a, 0x12, 0x9d, 0xf1, 0x6a, 0xef, - 0xa1, 0x52, 0x3d, 0x08, 0x52, 0xe0, 0xfc, 0x84, 0x72, 0x81, 0xef, 0xa2, 0x15, 0xa2, 0x3f, 0x81, - 0x57, 0xad, 0xfd, 0xc2, 0x41, 0xd9, 0x9d, 0x12, 0x6a, 0x3f, 0x46, 0xdb, 0x3f, 0x22, 0x21, 0x0d, - 0x88, 0x60, 0x69, 0x17, 0x44, 0x63, 0x48, 0xe2, 0x01, 0x74, 0x88, 0x7f, 0x06, 0x82, 0xe3, 0x07, - 0xa8, 0x18, 0x52, 0x2e, 0x14, 0xaa, 0x74, 0xff, 0x1d, 0x5b, 0xdd, 0xce, 0xf1, 0xa1, 0xfd, 0x3a, - 0x44, 0x93, 0x08, 0x72, 0x54, 0x94, 0xa6, 0xb9, 0x0a, 0x58, 0xfb, 0x95, 0x85, 0xaa, 0x8f, 0x61, - 0x52, 0xe7, 0x9c, 0x0e, 0xe2, 0x08, 0x62, 0xe1, 0x42, 0x12, 0x12, 0x1f, 0xe4, 0x12, 0x7f, 0x1d, - 0xad, 0x66, 0x37, 0xdd, 0x93, 0x06, 0xa9, 0x9c, 0x2b, 0xbb, 0xe5, 0x8c, 0x28, 0x0f, 0x81, 0xbf, - 0x87, 0x50, 0x92, 0xc2, 0xd8, 0xf3, 0xbd, 0x33, 0x98, 0xa8, 0xe4, 0x2a, 0xdd, 0xbf, 0x6b, 0xcf, - 0xdc, 0x03, 0x9d, 0xe1, 0x76, 0x67, 0xd4, 0x0f, 0xa9, 0xff, 0x18, 0x26, 0xee, 0xb2, 0x94, 0x6f, - 0x3c, 0x86, 0x09, 0x5e, 0x47, 0xb7, 0x12, 0x76, 0x0e, 0xa9, 0xca, 0xaf, 0x82, 0xab, 0x3f, 0x6a, - 0xbf, 0xb7, 0xd0, 0x56, 0x7e, 0x80, 0x06, 0x8b, 0xf9, 0x28, 0x82, 0xb4, 0x33, 0xea, 0x4b, 0xc4, - 0x1e, 0x2a, 0xf9, 0x86, 0xe2, 0xd1, 0x40, 0x19, 0x54, 0x74, 0x51, 0x46, 0x6a, 0x07, 0x57, 0x6d, - 0x5e, 0xbc, 0xc6, 0xe6, 0x07, 0xa8, 0x9c, 0x6b, 0x91, 0x56, 0x17, 0x6e, 0x60, 0x75, 0xbe, 0xef, - 0x63, 0x98, 0xd4, 0x7e, 0x31, 0x6b, 0xe2, 0xd1, 0x24, 0x33, 0x52, 0x29, 0xbf, 0x89, 0x89, 0xb9, - 0xc0, 0xac, 0x89, 0xfe, 0xac, 0x96, 0x2b, 0xe7, 0x28, 0x5c, 0x3d, 0x47, 0xed, 0xaf, 0x16, 0x5a, - 0x9f, 0xdd, 0x9b, 0xf7, 0x58, 0x27, 0x1d, 0xc5, 0xf0, 0xd5, 0x36, 0x3c, 0x40, 0xcb, 0x89, 0x94, - 0xf4, 0x04, 0x37, 0x31, 0xdb, 0xb9, 0x92, 0xcb, 0xbd, 0xac, 0x38, 0xea, 0x64, 0xfe, 0x44, 0x26, - 0xf3, 0x1b, 0x0a, 0xd5, 0xe3, 0xb8, 0x89, 0x6e, 0xbf, 0x72, 0x08, 0x6e, 0x9c, 0xf8, 0x96, 0x7d, - 0xb9, 0x43, 0xd8, 0x33, 0xb9, 0xee, 0xae, 0xce, 0x1e, 0x92, 0xd7, 0xfe, 0x62, 0x21, 0x2c, 0x0f, - 0x00, 0x31, 0x1f, 0xf1, 0xdc, 0xa1, 0xf2, 0x86, 0xe6, 0x87, 0x97, 0x80, 0xd9, 0xec, 0xab, 0x64, - 0x1c, 0x89, 0x53, 0xae, 0xca, 0xb3, 0x68, 0x71, 0x26, 0x8b, 0xf0, 0xf7, 0x11, 0x4a, 0x54, 0xf0, - 0x6e, 0x1c, 0xe1, 0x95, 0x24, 0x5b, 0x4a, 0xff, 0x7d, 0xcc, 0x68, 0xec, 0x0d, 0x41, 0x96, 0x7a, - 0x53, 0xac, 0x90, 0x24, 0x1d, 0x2b, 0x4a, 0x2d, 0x40, 0x95, 0xcc, 0xf1, 0x4f, 0x40, 0x90, 0x80, - 0x08, 0x82, 0x31, 0x2a, 0xc6, 0x24, 0x02, 0x53, 0x99, 0xd5, 0x1a, 0xef, 0xa3, 0x52, 0x00, 0xdc, - 0x4f, 0x69, 0x32, 0x53, 0x7b, 0x67, 0x49, 0x78, 0x07, 0x2d, 0x47, 0x46, 0x83, 0xb2, 0x72, 0xc5, - 0xcd, 0xbf, 0x6b, 0xbf, 0x2b, 0xa2, 0xfd, 0x6c, 0x9b, 0x76, 0x4c, 0x05, 0x25, 0x21, 0xfd, 0x99, - 0xaa, 0x21, 0xaa, 0x41, 0x80, 0x80, 0x94, 0xe3, 0x47, 0xe8, 0x36, 0xd5, 0xbc, 0xcc, 0x5c, 0xcb, - 0x04, 0x94, 0xf6, 0x7d, 0x5b, 0x36, 0x33, 0xdb, 0xb4, 0xb0, 0xf1, 0xa1, 0xad, 0xcd, 0x37, 0x25, - 0x60, 0xd5, 0xe0, 0x34, 0x11, 0xbf, 0x8d, 0xca, 0x03, 0xd9, 0x12, 0x28, 0xf7, 0x86, 0x84, 0x0f, - 0x4d, 0x5a, 0x96, 0x0c, 0xed, 0x98, 0xf0, 0xa1, 0xf4, 0x4b, 0x9f, 0xc6, 0x24, 0x9d, 0x68, 0x09, - 0x9d, 0x93, 0x48, 0x93, 0x94, 0x40, 0x03, 0x21, 0x9e, 0x90, 0xf3, 0x58, 0x35, 0x10, 0xe5, 0xb7, - 0x9b, 0x66, 0xd6, 0x8a, 0xc2, 0x49, 0x0e, 0x3e, 0x45, 0x95, 0x51, 0xdc, 0x67, 0x71, 0x30, 0xed, - 0x7b, 0xaa, 0x01, 0xdc, 0xb0, 0xe0, 0x7e, 0x2d, 0x07, 0x9b, 0xfe, 0xf3, 0x9a, 0xa6, 0xb6, 0xf4, - 0x3f, 0x35, 0xb5, 0xf7, 0x11, 0x1e, 0x52, 0x2e, 0x58, 0x4a, 0x7d, 0x12, 0x7a, 0x10, 0x8b, 0x94, - 0x02, 0x57, 0x7d, 0xa1, 0xe0, 0xae, 0x4d, 0x39, 0x2d, 0xcd, 0x90, 0x36, 0x70, 0xf2, 0x1c, 0xbc, - 0x88, 0x05, 0xe0, 0x89, 0x61, 0x0a, 0x7c, 0xc8, 0xc2, 0xa0, 0xba, 0x3c, 0x87, 0x0d, 0x12, 0xff, - 0x84, 0x05, 0xd0, 0xcb, 0xd0, 0xb5, 0x3d, 0x54, 0xca, 0xd3, 0x23, 0xe0, 0xb8, 0x82, 0x0a, 0x34, - 0xd0, 0x2d, 0xa4, 0xe8, 0xca, 0x65, 0xed, 0xef, 0x45, 0xb4, 0xde, 0x8e, 0xb3, 0xd6, 0x3f, 0x93, - 0x34, 0x0f, 0x51, 0x29, 0x60, 0xa3, 0x7e, 0x08, 0x9e, 0x2c, 0xfc, 0x26, 0x63, 0xde, 0xb9, 0x7a, - 0x77, 0xbb, 0x21, 0xe1, 0xc3, 0x1f, 0x10, 0x1a, 0x4e, 0xb1, 0x2e, 0xd2, 0xc8, 0x2e, 0x1d, 0xc4, - 0xb8, 0x8e, 0x96, 0x03, 0x76, 0x1e, 0xab, 0x68, 0x2f, 0xce, 0xa3, 0x24, 0x87, 0xe1, 0x67, 0x68, - 0x23, 0x5b, 0x9b, 0x51, 0x65, 0xfe, 0xa1, 0xe3, 0x4e, 0xa6, 0x41, 0x4d, 0x33, 0x26, 0x42, 0xf7, - 0xd0, 0xba, 0x3c, 0x1c, 0x04, 0xa6, 0xc5, 0x7b, 0xe7, 0x34, 0x0e, 0xd8, 0xb9, 0xb9, 0xcd, 0x58, - 0xf3, 0x74, 0x97, 0x7f, 0xa6, 0x38, 0x38, 0x40, 0x1b, 0x72, 0x32, 0x30, 0x28, 0x39, 0x84, 0x18, - 0x88, 0x1e, 0x3f, 0x0e, 0xcd, 0xf8, 0xf1, 0xe6, 0xd5, 0xf1, 0xe3, 0x04, 0x06, 0xc4, 0x9f, 0x34, - 0xc1, 0x9f, 0x19, 0x42, 0x9a, 0xe0, 0xbb, 0x72, 0xd2, 0xe8, 0x2a, 0x75, 0x1d, 0x48, 0xcd, 0x2e, - 0x1e, 0xda, 0xce, 0x0f, 0xec, 0x0f, 0x49, 0x18, 0x42, 0x3c, 0x80, 0x6c, 0xa7, 0x39, 0x92, 0x72, - 0x2b, 0xd3, 0xd2, 0xc8, 0x94, 0x98, 0x0d, 0x7e, 0x3a, 0xb3, 0x41, 0x36, 0x21, 0x7b, 0x72, 0x88, - 0x21, 0x03, 0x98, 0x67, 0x72, 0xd9, 0xcc, 0xb4, 0xb4, 0x8c, 0x92, 0x27, 0xe4, 0xa2, 0x3e, 0x80, - 0xda, 0xaf, 0x0b, 0x68, 0xbd, 0x03, 0xea, 0x86, 0x35, 0x8d, 0x84, 0x0a, 0xf1, 0x57, 0xb7, 0x9d, - 0xeb, 0x0b, 0xfb, 0xe2, 0x6b, 0x0a, 0xbb, 0x8d, 0xee, 0x68, 0xaf, 0x78, 0x5c, 0x90, 0x54, 0x64, - 0xe5, 0x4d, 0x0f, 0x0b, 0x6b, 0x9a, 0xd5, 0x95, 0x1c, 0x53, 0xc0, 0x30, 0x2a, 0xf2, 0x84, 0xc4, - 0x26, 0xc0, 0x6a, 0x2d, 0x8b, 0x5a, 0x44, 0x39, 0x87, 0xc0, 0xf3, 0xf3, 0x41, 0xb2, 0xe0, 0x96, - 0x34, 0xad, 0xa1, 0xe6, 0xc1, 0x7b, 0x68, 0xdd, 0x88, 0x98, 0x3c, 0xe9, 0x53, 0x11, 0x91, 0x44, - 0x85, 0xa2, 0x2c, 0x23, 0x28, 0x79, 0x3a, 0x4f, 0x8e, 0x14, 0x07, 0x9f, 0xa2, 0x32, 0x97, 0x07, - 0xf6, 0x04, 0x3b, 0x83, 0x58, 0xdf, 0xfa, 0x95, 0xa3, 0xf7, 0xe6, 0x98, 0x4e, 0xdd, 0x92, 0x52, - 0xd0, 0x53, 0x78, 0x59, 0x35, 0x23, 0x22, 0x46, 0x29, 0x70, 0x8f, 0x08, 0x53, 0x13, 0x6e, 0x58, - 0x35, 0x0d, 0xae, 0x2e, 0x6a, 0x3f, 0xb7, 0xd0, 0x66, 0xdd, 0xf7, 0x21, 0x11, 0x10, 0x64, 0x61, - 0x31, 0x09, 0xf1, 0x36, 0x2a, 0xcf, 0x3a, 0x52, 0x05, 0xa6, 0xe0, 0x96, 0x66, 0x3c, 0x88, 0x5b, - 0xa8, 0x44, 0x0c, 0x58, 0xda, 0x30, 0xcf, 0x4c, 0x80, 0x32, 0x60, 0x5d, 0xd4, 0x7e, 0x63, 0xa1, - 0xcd, 0x4e, 0x0a, 0x63, 0xca, 0x46, 0x3c, 0x33, 0xc2, 0x3c, 0x66, 0xbe, 0x8d, 0x96, 0x12, 0xb5, - 0x32, 0xd5, 0x66, 0x2b, 0x9f, 0x56, 0x5f, 0x15, 0x34, 0xcd, 0xc9, 0x08, 0x4b, 0xdf, 0xf8, 0x6a, - 0x82, 0x9d, 0xdb, 0xae, 0x15, 0x83, 0xab, 0x8b, 0xda, 0x97, 0x16, 0x5a, 0x7b, 0x46, 0xc5, 0x70, - 0x08, 0x61, 0xf0, 0x10, 0xc0, 0x05, 0x9f, 0xa5, 0xc1, 0xff, 0x3b, 0x5d, 0xbf, 0x83, 0x96, 0xcc, - 0x6b, 0x25, 0xab, 0x5c, 0x26, 0xde, 0xf2, 0x59, 0x6b, 0x9b, 0x27, 0xab, 0xdd, 0x60, 0x34, 0xce, - 0x8e, 0xa8, 0xc5, 0xe5, 0x11, 0xe1, 0x22, 0xa1, 0x26, 0xfc, 0x73, 0x35, 0x4d, 0x83, 0xab, 0x8b, - 0xda, 0xbf, 0x2c, 0x74, 0xe7, 0x9a, 0x42, 0x8b, 0x7f, 0x82, 0x6e, 0xeb, 0x5c, 0x7d, 0xe5, 0xe5, - 0x58, 0x3e, 0xfa, 0x60, 0xee, 0x62, 0xa6, 0x5f, 0x54, 0xab, 0x4a, 0x5b, 0xfe, 0x60, 0x3c, 0x46, - 0xab, 0x1f, 0x13, 0x1a, 0x4e, 0x5f, 0x46, 0x8b, 0x37, 0xaf, 0x2f, 0x65, 0x89, 0xcc, 0xe8, 0xf2, - 0x19, 0x24, 0x58, 0xd4, 0xe7, 0x82, 0xc5, 0xa0, 0x3c, 0xb8, 0xec, 0x4e, 0x09, 0xef, 0xfe, 0xdb, - 0x42, 0xab, 0xf9, 0x5b, 0x60, 0x48, 0x38, 0xe0, 0x5d, 0xb4, 0xd3, 0xf8, 0xf0, 0xb4, 0xfb, 0xf4, - 0x49, 0xcb, 0xf5, 0x3a, 0xc7, 0xf5, 0x6e, 0xcb, 0x7b, 0x7a, 0xda, 0xed, 0xb4, 0x1a, 0xed, 0x87, - 0xed, 0x56, 0xb3, 0xb2, 0x80, 0xdf, 0x42, 0xdb, 0x97, 0xf8, 0x6e, 0xeb, 0x51, 0xbb, 0xdb, 0x6b, - 0xb9, 0xad, 0x66, 0xc5, 0xba, 0x06, 0xde, 0x3e, 0x6d, 0xf7, 0xda, 0xf5, 0x93, 0xf6, 0x47, 0xad, - 0x66, 0x65, 0x11, 0xbf, 0x89, 0xb6, 0x2e, 0xf1, 0x4f, 0xea, 0x4f, 0x4f, 0x1b, 0xc7, 0xad, 0x66, - 0xa5, 0x80, 0x77, 0xd0, 0xe6, 0x25, 0x66, 0xb7, 0xf7, 0x61, 0xa7, 0xd3, 0x6a, 0x56, 0x8a, 0xd7, - 0xf0, 0x9a, 0xad, 0x93, 0x56, 0xaf, 0xd5, 0xac, 0xdc, 0xc2, 0xdb, 0x68, 0xe3, 0x12, 0xaf, 0x53, - 0x7f, 0xda, 0x6d, 0x35, 0x2b, 0x4b, 0x3b, 0xc5, 0x5f, 0xfe, 0x61, 0x77, 0xe1, 0xa8, 0xfd, 0xe9, - 0x8b, 0x5d, 0xeb, 0xb3, 0x17, 0xbb, 0xd6, 0x97, 0x2f, 0x76, 0xad, 0x4f, 0x5e, 0xee, 0x2e, 0x7c, - 0xf6, 0x72, 0x77, 0xe1, 0x1f, 0x2f, 0x77, 0x17, 0x3e, 0x72, 0x06, 0x54, 0x0c, 0x47, 0x7d, 0xdb, - 0x67, 0x91, 0x43, 0xc2, 0x90, 0xc6, 0x7d, 0x2a, 0xb8, 0xa3, 0xfe, 0x5d, 0xb8, 0x70, 0x5e, 0xfd, - 0xdb, 0x46, 0x4c, 0x12, 0xe0, 0xfd, 0x25, 0xe5, 0xfa, 0x6f, 0xfd, 0x37, 0x00, 0x00, 0xff, 0xff, - 0x9b, 0xf2, 0x15, 0xae, 0xd4, 0x11, 0x00, 0x00, + 0x95, 0x9d, 0x98, 0x23, 0xe2, 0xc0, 0x71, 0x91, 0x38, 0x70, 0x41, 0x42, 0xe2, 0xc2, 0x91, 0x03, + 0xe2, 0x88, 0xc4, 0x6d, 0x8f, 0x2b, 0xb8, 0x20, 0x84, 0x76, 0x57, 0x33, 0x48, 0xfc, 0x1b, 0xa8, + 0x3e, 0xba, 0xed, 0x49, 0x32, 0xda, 0x58, 0x70, 0xb1, 0xaa, 0xdf, 0x7b, 0xbf, 0x57, 0xef, 0xbd, + 0x7a, 0xf5, 0xde, 0x2b, 0xa3, 0xbd, 0x31, 0x21, 0xdc, 0x49, 0x52, 0x36, 0xa6, 0x01, 0xa4, 0xce, + 0xf8, 0x30, 0x5f, 0xdb, 0x49, 0xca, 0x04, 0xc3, 0x15, 0x29, 0x60, 0xe7, 0xc4, 0xf1, 0xe1, 0xce, + 0x1a, 0x89, 0x68, 0xcc, 0x1c, 0xf5, 0xab, 0x85, 0x76, 0xb6, 0x7d, 0xc6, 0x23, 0xc6, 0x3d, 0xf5, + 0xe5, 0xe8, 0x0f, 0xc3, 0x5a, 0x1f, 0xb0, 0x01, 0xd3, 0x74, 0xb9, 0x32, 0xd4, 0x5d, 0x2d, 0xe3, + 0xf4, 0x09, 0x07, 0x67, 0x7c, 0xd8, 0x07, 0x41, 0x0e, 0x1d, 0x9f, 0xd1, 0xd8, 0xf0, 0xbf, 0x61, + 0xf8, 0x20, 0x77, 0x8d, 0xfd, 0xa9, 0x4c, 0x46, 0xc8, 0xf4, 0x0c, 0x18, 0x1b, 0x84, 0xe0, 0xa8, + 0xaf, 0xfe, 0xe8, 0xb9, 0x13, 0x8c, 0x52, 0x22, 0x28, 0xcb, 0xf4, 0xec, 0x5d, 0xe6, 0x0b, 0x1a, + 0x01, 0x17, 0x24, 0x4a, 0x32, 0x01, 0xda, 0xf7, 0x1d, 0x9f, 0xa5, 0xe0, 0xf8, 0x21, 0x85, 0x58, + 0xc8, 0x08, 0xe8, 0x95, 0x11, 0x70, 0xa4, 0x40, 0x48, 0x07, 0x43, 0xa1, 0xc9, 0xdc, 0x11, 0x10, + 0x07, 0x90, 0x46, 0x54, 0x0b, 0x4f, 0xbf, 0x0c, 0x00, 0xab, 0x88, 0x8e, 0x0f, 0x9d, 0x73, 0x9a, + 0x66, 0x66, 0xde, 0x9d, 0xc1, 0xf8, 0xe9, 0x24, 0x11, 0xcc, 0x39, 0x83, 0x89, 0x09, 0x51, 0xed, + 0x8b, 0x02, 0x5a, 0xea, 0x90, 0x94, 0x44, 0x1c, 0x7f, 0x17, 0x55, 0x45, 0x3a, 0xe2, 0x82, 0xc6, + 0x03, 0x2f, 0x81, 0x94, 0xb2, 0xc0, 0x7b, 0x9e, 0x12, 0x5f, 0x7a, 0x54, 0xb5, 0xf6, 0xad, 0x83, + 0x15, 0x77, 0x33, 0xe3, 0x77, 0x14, 0xfb, 0xa1, 0xe1, 0xe2, 0x0f, 0xd0, 0x56, 0x48, 0xc7, 0x10, + 0x03, 0xe7, 0xde, 0x20, 0x25, 0x3e, 0x4c, 0x81, 0x8b, 0x0a, 0xb8, 0x91, 0xb1, 0x1f, 0x49, 0x6e, + 0x8e, 0xeb, 0xa2, 0x3b, 0xd2, 0x60, 0x4f, 0x06, 0x86, 0x8d, 0x84, 0xd9, 0xb5, 0x5a, 0xd8, 0xb7, + 0x0e, 0x4a, 0xf7, 0xb7, 0x6d, 0x1d, 0x3f, 0x3b, 0x8b, 0x9f, 0xdd, 0x34, 0xf1, 0x3d, 0x5a, 0xfe, + 0xf4, 0xf3, 0xbd, 0x85, 0xdf, 0x7c, 0xb1, 0x67, 0xb9, 0x6b, 0x12, 0xdf, 0xd3, 0x70, 0x6d, 0x14, + 0x3e, 0x40, 0x95, 0x7e, 0xc8, 0xfc, 0x33, 0x2e, 0xd5, 0x79, 0x90, 0x30, 0x7f, 0x58, 0x2d, 0xee, + 0x5b, 0x07, 0x05, 0xf7, 0xb6, 0xa6, 0x77, 0x20, 0x6d, 0x49, 0x2a, 0xf6, 0xd1, 0xc6, 0x73, 0x00, + 0x2d, 0xa7, 0x58, 0x1e, 0x89, 0xd8, 0x28, 0x16, 0xd5, 0x5b, 0xd2, 0xe8, 0xa3, 0x7b, 0x72, 0x97, + 0x7f, 0x7e, 0xbe, 0xb7, 0xa1, 0xf3, 0x81, 0x07, 0x67, 0x36, 0x65, 0x4e, 0x44, 0xc4, 0xd0, 0x6e, + 0xc7, 0xe2, 0x6f, 0x7f, 0x7a, 0x1f, 0x99, 0x64, 0x6b, 0xc7, 0xe2, 0x0f, 0xff, 0xf9, 0xe3, 0xbb, + 0x96, 0x8b, 0xa5, 0xba, 0x0e, 0xa4, 0x47, 0x52, 0x59, 0x5d, 0xe9, 0xc2, 0xdf, 0x44, 0x38, 0xa2, + 0xb1, 0x17, 0x40, 0xc2, 0x38, 0x15, 0x7a, 0x1f, 0x5e, 0x5d, 0xda, 0xb7, 0x0e, 0x8a, 0x6e, 0x25, + 0xa2, 0x71, 0x53, 0x33, 0x14, 0x84, 0xe3, 0x1f, 0x22, 0x1c, 0x91, 0x0b, 0x2f, 0x21, 0x23, 0x0e, + 0x5e, 0x96, 0x4f, 0xd5, 0x37, 0x6e, 0x1e, 0x90, 0x4a, 0x44, 0x2e, 0x3a, 0x12, 0x9d, 0xf1, 0x6a, + 0xef, 0xa1, 0x52, 0x3d, 0x08, 0x52, 0xe0, 0xfc, 0x84, 0x72, 0x81, 0xef, 0xa2, 0x15, 0xa2, 0x3f, + 0x81, 0x57, 0xad, 0xfd, 0xc2, 0x41, 0xd9, 0x9d, 0x12, 0x6a, 0x3f, 0x46, 0xdb, 0x3f, 0x22, 0x21, + 0x0d, 0x88, 0x60, 0x69, 0x17, 0x44, 0x63, 0x48, 0xe2, 0x01, 0x74, 0x88, 0x7f, 0x06, 0x82, 0xe3, + 0x07, 0xa8, 0x18, 0x52, 0x2e, 0x14, 0xaa, 0x74, 0xff, 0x1d, 0x5b, 0xdd, 0xce, 0xf1, 0xa1, 0xfd, + 0x3a, 0x44, 0x93, 0x08, 0x72, 0x54, 0x94, 0xa6, 0xb9, 0x0a, 0x58, 0xfb, 0x95, 0x85, 0xaa, 0x8f, + 0x61, 0x52, 0xe7, 0x9c, 0x0e, 0xe2, 0x08, 0x62, 0xe1, 0x42, 0x12, 0x12, 0x1f, 0xe4, 0x12, 0x7f, + 0x1d, 0xad, 0x66, 0x37, 0xdd, 0x93, 0x06, 0xa9, 0x9c, 0x2b, 0xbb, 0xe5, 0x8c, 0x28, 0x9d, 0xc0, + 0xdf, 0x43, 0x28, 0x49, 0x61, 0xec, 0xf9, 0xde, 0x19, 0x4c, 0x54, 0x72, 0x95, 0xee, 0xdf, 0xb5, + 0x67, 0xee, 0x81, 0xce, 0x70, 0xbb, 0x33, 0xea, 0x87, 0xd4, 0x7f, 0x0c, 0x13, 0x77, 0x59, 0xca, + 0x37, 0x1e, 0xc3, 0x04, 0xaf, 0xa3, 0x5b, 0x09, 0x3b, 0x87, 0x54, 0xe5, 0x57, 0xc1, 0xd5, 0x1f, + 0xb5, 0xdf, 0x59, 0x68, 0x2b, 0x77, 0xa0, 0xc1, 0x62, 0x3e, 0x8a, 0x20, 0xed, 0x8c, 0xfa, 0x12, + 0xb1, 0x87, 0x4a, 0xbe, 0xa1, 0x78, 0x34, 0x50, 0x06, 0x15, 0x5d, 0x94, 0x91, 0xda, 0xc1, 0x55, + 0x9b, 0x17, 0xaf, 0xb1, 0xf9, 0x01, 0x2a, 0xe7, 0x5a, 0xa4, 0xd5, 0x85, 0x1b, 0x58, 0x9d, 0xef, + 0xfb, 0x18, 0x26, 0xb5, 0x5f, 0xcc, 0x9a, 0x78, 0x34, 0xc9, 0x8c, 0x54, 0xca, 0x6f, 0x62, 0x62, + 0x2e, 0x30, 0x6b, 0xa2, 0x3f, 0xab, 0xe5, 0x8a, 0x1f, 0x85, 0xab, 0x7e, 0xd4, 0xfe, 0x62, 0xa1, + 0xf5, 0xd9, 0xbd, 0x79, 0x8f, 0x75, 0xd2, 0x51, 0x0c, 0x5f, 0x6d, 0xc3, 0x03, 0xb4, 0x9c, 0x48, + 0x49, 0x4f, 0x70, 0x73, 0x66, 0x3b, 0x57, 0x72, 0xb9, 0x97, 0x15, 0x47, 0x9d, 0xcc, 0x9f, 0xc8, + 0x64, 0x7e, 0x43, 0xa1, 0x7a, 0x1c, 0x37, 0xd1, 0xed, 0x57, 0x9c, 0xe0, 0x26, 0x88, 0x6f, 0xd9, + 0x97, 0x3b, 0x84, 0x3d, 0x93, 0xeb, 0xee, 0xea, 0xac, 0x93, 0xbc, 0xf6, 0x67, 0x0b, 0x61, 0xe9, + 0x00, 0xc4, 0x7c, 0xc4, 0xf3, 0x80, 0xca, 0x1b, 0x9a, 0x3b, 0x2f, 0x01, 0xb3, 0xd9, 0x57, 0xc9, + 0x38, 0x12, 0xa7, 0x42, 0x95, 0x67, 0xd1, 0xe2, 0x4c, 0x16, 0xe1, 0xef, 0x23, 0x94, 0xa8, 0xc3, + 0xbb, 0xf1, 0x09, 0xaf, 0x24, 0xd9, 0x52, 0xc6, 0xef, 0x63, 0x46, 0x63, 0x6f, 0x08, 0xb2, 0xd4, + 0x9b, 0x62, 0x85, 0x24, 0xe9, 0x58, 0x51, 0x6a, 0x01, 0xaa, 0x64, 0x81, 0x7f, 0x02, 0x82, 0x04, + 0x44, 0x10, 0x8c, 0x51, 0x31, 0x26, 0x11, 0x98, 0xca, 0xac, 0xd6, 0x78, 0x1f, 0x95, 0x02, 0xe0, + 0x7e, 0x4a, 0x93, 0x99, 0xda, 0x3b, 0x4b, 0xc2, 0x3b, 0x68, 0x39, 0x32, 0x1a, 0x94, 0x95, 0x2b, + 0x6e, 0xfe, 0x5d, 0xfb, 0x6d, 0x11, 0xed, 0x67, 0xdb, 0xb4, 0x63, 0x2a, 0x28, 0x09, 0xe9, 0xcf, + 0x54, 0x0d, 0x51, 0x0d, 0x02, 0x04, 0xa4, 0x1c, 0x3f, 0x42, 0xb7, 0xa9, 0xe6, 0x65, 0xe6, 0x5a, + 0xe6, 0x40, 0x69, 0xdf, 0xb7, 0x65, 0x33, 0xb3, 0x4d, 0x0b, 0x1b, 0x1f, 0xda, 0xda, 0x7c, 0x53, + 0x02, 0x56, 0x0d, 0x4e, 0x13, 0xf1, 0xdb, 0xa8, 0x3c, 0x90, 0x2d, 0x81, 0x72, 0x6f, 0x48, 0xf8, + 0xd0, 0xa4, 0x65, 0xc9, 0xd0, 0x8e, 0x09, 0x1f, 0xca, 0xb8, 0xf4, 0x69, 0x4c, 0xd2, 0x89, 0x96, + 0xd0, 0x39, 0x89, 0x34, 0x49, 0x09, 0x34, 0x10, 0xe2, 0x09, 0x39, 0x8f, 0x55, 0x03, 0x51, 0x71, + 0xbb, 0x69, 0x66, 0xad, 0x28, 0x9c, 0xe4, 0xe0, 0x53, 0x54, 0x19, 0xc5, 0x7d, 0x16, 0x07, 0xd3, + 0xbe, 0xa7, 0x1a, 0xc0, 0x0d, 0x0b, 0xee, 0xd7, 0x72, 0xb0, 0xe9, 0x3f, 0xaf, 0x69, 0x6a, 0x4b, + 0xff, 0x53, 0x53, 0x7b, 0x1f, 0xe1, 0x21, 0xe5, 0x82, 0xa5, 0xd4, 0x27, 0xa1, 0x07, 0xb1, 0x48, + 0x29, 0x70, 0xd5, 0x17, 0x0a, 0xee, 0xda, 0x94, 0xd3, 0xd2, 0x0c, 0x69, 0x03, 0x27, 0xcf, 0xc1, + 0x8b, 0x58, 0x00, 0x9e, 0x18, 0xa6, 0xc0, 0x87, 0x2c, 0x0c, 0xaa, 0xcb, 0x73, 0xd8, 0x20, 0xf1, + 0x4f, 0x58, 0x00, 0xbd, 0x0c, 0x5d, 0xdb, 0x43, 0xa5, 0x3c, 0x3d, 0x02, 0x8e, 0x2b, 0xa8, 0x40, + 0x03, 0xdd, 0x42, 0x8a, 0xae, 0x5c, 0xd6, 0xfe, 0x5e, 0x44, 0xeb, 0xed, 0x38, 0x6b, 0xfd, 0x33, + 0x49, 0xf3, 0x10, 0x95, 0x02, 0x36, 0xea, 0x87, 0xe0, 0xc9, 0xc2, 0x6f, 0x32, 0xe6, 0x9d, 0xab, + 0x77, 0xb7, 0x1b, 0x12, 0x3e, 0xfc, 0x01, 0xa1, 0xe1, 0x14, 0xeb, 0x22, 0x8d, 0xec, 0xd2, 0x41, + 0x8c, 0xeb, 0x68, 0x39, 0x60, 0xe7, 0xb1, 0x3a, 0xed, 0xc5, 0x79, 0x94, 0xe4, 0x30, 0xfc, 0x0c, + 0x6d, 0x64, 0x6b, 0x33, 0xaa, 0xcc, 0x3f, 0x74, 0xdc, 0xc9, 0x34, 0xa8, 0x69, 0xc6, 0x9c, 0xd0, + 0x3d, 0xb4, 0x2e, 0x9d, 0x83, 0xc0, 0xb4, 0x78, 0xef, 0x9c, 0xc6, 0x01, 0x3b, 0x37, 0xb7, 0x19, + 0x6b, 0x9e, 0xee, 0xf2, 0xcf, 0x14, 0x07, 0x07, 0x68, 0x43, 0x4e, 0x06, 0x06, 0x25, 0x87, 0x10, + 0x03, 0xd1, 0xe3, 0xc7, 0xa1, 0x19, 0x3f, 0xde, 0xbc, 0x3a, 0x7e, 0x9c, 0xc0, 0x80, 0xf8, 0x93, + 0x26, 0xf8, 0x33, 0x43, 0x48, 0x13, 0x7c, 0x57, 0x4e, 0x1a, 0x5d, 0xa5, 0xae, 0x03, 0xa9, 0xd9, + 0xc5, 0x43, 0xdb, 0xb9, 0xc3, 0xfe, 0x90, 0x84, 0x21, 0xc4, 0x03, 0xc8, 0x76, 0x9a, 0x23, 0x29, + 0xb7, 0x32, 0x2d, 0x8d, 0x4c, 0x89, 0xd9, 0xe0, 0xa7, 0x33, 0x1b, 0x64, 0x13, 0xb2, 0x27, 0x87, + 0x18, 0x32, 0x80, 0x79, 0x26, 0x97, 0xcd, 0x4c, 0x4b, 0xcb, 0x28, 0x79, 0x42, 0x2e, 0xea, 0x03, + 0xa8, 0xfd, 0xb5, 0x80, 0xd6, 0x3b, 0xa0, 0x6e, 0x58, 0xd3, 0x48, 0xa8, 0x23, 0xfe, 0xea, 0xb6, + 0x73, 0x7d, 0x61, 0x5f, 0x7c, 0x4d, 0x61, 0xb7, 0xd1, 0x1d, 0x1d, 0x15, 0x8f, 0x0b, 0x92, 0x8a, + 0xac, 0xbc, 0xe9, 0x61, 0x61, 0x4d, 0xb3, 0xba, 0x92, 0x63, 0x0a, 0x18, 0x46, 0x45, 0x9e, 0x90, + 0xd8, 0x1c, 0xb0, 0x5a, 0xcb, 0xa2, 0x16, 0x51, 0xce, 0x21, 0xf0, 0xfc, 0x7c, 0x90, 0x2c, 0xb8, + 0x25, 0x4d, 0x6b, 0xa8, 0x79, 0xf0, 0x1e, 0x5a, 0x37, 0x22, 0x26, 0x4f, 0xfa, 0x54, 0x44, 0x24, + 0x51, 0x47, 0x51, 0x96, 0x27, 0x28, 0x79, 0x3a, 0x4f, 0x8e, 0x14, 0x07, 0x9f, 0xa2, 0x32, 0x97, + 0x0e, 0x7b, 0x82, 0x9d, 0x41, 0xac, 0x6f, 0xfd, 0xca, 0xd1, 0x7b, 0x73, 0x4c, 0xa7, 0x6e, 0x49, + 0x29, 0xe8, 0x29, 0xbc, 0xac, 0x9a, 0x11, 0x11, 0xa3, 0x14, 0xb8, 0x47, 0x84, 0xa9, 0x09, 0x37, + 0xac, 0x9a, 0x06, 0x57, 0x57, 0x63, 0x6d, 0x1e, 0xfc, 0x69, 0x6c, 0x57, 0x74, 0x6c, 0x33, 0x4e, + 0x16, 0xdb, 0xda, 0xcf, 0x2d, 0xb4, 0x59, 0xf7, 0x7d, 0x48, 0x04, 0x04, 0xd9, 0x21, 0x9a, 0xf4, + 0x79, 0x1b, 0x95, 0x67, 0xc3, 0xae, 0x8e, 0xb1, 0xe0, 0x96, 0x66, 0xe2, 0x8d, 0x5b, 0xa8, 0x44, + 0x0c, 0x58, 0x5a, 0x3c, 0xcf, 0x04, 0x81, 0x32, 0x60, 0x5d, 0xd4, 0x7e, 0x6d, 0xa1, 0xcd, 0x4e, + 0x0a, 0x63, 0xca, 0x46, 0x3c, 0x33, 0xc2, 0x3c, 0x7d, 0xbe, 0x8d, 0x96, 0x12, 0xb5, 0x32, 0xb5, + 0x69, 0x2b, 0x9f, 0x6d, 0x5f, 0x15, 0x34, 0xad, 0xcc, 0x08, 0xcb, 0x48, 0xfa, 0x6a, 0xde, 0x9d, + 0xdb, 0xae, 0x15, 0x83, 0xab, 0x8b, 0xda, 0x97, 0x16, 0x5a, 0x7b, 0x46, 0xc5, 0x70, 0x08, 0x61, + 0xf0, 0x10, 0xc0, 0x05, 0x9f, 0xa5, 0xc1, 0xff, 0x3b, 0xb9, 0xbf, 0x83, 0x96, 0xcc, 0xdb, 0x26, + 0xab, 0x73, 0x26, 0x3b, 0xe4, 0x23, 0xd8, 0x36, 0x0f, 0x5c, 0xbb, 0xc1, 0x68, 0x9c, 0xb9, 0xa8, + 0xc5, 0xa5, 0x8b, 0x70, 0x91, 0x50, 0x93, 0x2c, 0x73, 0xb5, 0x58, 0x83, 0xab, 0x8b, 0xda, 0xbf, + 0x2c, 0x74, 0xe7, 0x9a, 0xb2, 0x8c, 0x7f, 0x82, 0x6e, 0xeb, 0xcc, 0x7e, 0xe5, 0x9d, 0x59, 0x3e, + 0xfa, 0x60, 0xee, 0xd2, 0xa7, 0xdf, 0x5f, 0xab, 0x4a, 0x5b, 0xfe, 0xbc, 0x3c, 0x46, 0xab, 0x1f, + 0x13, 0x1a, 0x4e, 0xdf, 0x51, 0x8b, 0x37, 0xaf, 0x46, 0x65, 0x89, 0xcc, 0xe8, 0xf2, 0xd1, 0x24, + 0x58, 0xd4, 0xe7, 0x82, 0xc5, 0xa0, 0x22, 0xb8, 0xec, 0x4e, 0x09, 0xef, 0xfe, 0xdb, 0x42, 0xab, + 0xf9, 0xcb, 0x61, 0x48, 0x38, 0xe0, 0x5d, 0xb4, 0xd3, 0xf8, 0xf0, 0xb4, 0xfb, 0xf4, 0x49, 0xcb, + 0xf5, 0x3a, 0xc7, 0xf5, 0x6e, 0xcb, 0x7b, 0x7a, 0xda, 0xed, 0xb4, 0x1a, 0xed, 0x87, 0xed, 0x56, + 0xb3, 0xb2, 0x80, 0xdf, 0x42, 0xdb, 0x97, 0xf8, 0x6e, 0xeb, 0x51, 0xbb, 0xdb, 0x6b, 0xb9, 0xad, + 0x66, 0xc5, 0xba, 0x06, 0xde, 0x3e, 0x6d, 0xf7, 0xda, 0xf5, 0x93, 0xf6, 0x47, 0xad, 0x66, 0x65, + 0x11, 0xbf, 0x89, 0xb6, 0x2e, 0xf1, 0x4f, 0xea, 0x4f, 0x4f, 0x1b, 0xc7, 0xad, 0x66, 0xa5, 0x80, + 0x77, 0xd0, 0xe6, 0x25, 0x66, 0xb7, 0xf7, 0x61, 0xa7, 0xd3, 0x6a, 0x56, 0x8a, 0xd7, 0xf0, 0x9a, + 0xad, 0x93, 0x56, 0xaf, 0xd5, 0xac, 0xdc, 0xc2, 0xdb, 0x68, 0xe3, 0x12, 0xaf, 0x53, 0x7f, 0xda, + 0x6d, 0x35, 0x2b, 0x4b, 0x3b, 0xc5, 0x5f, 0xfe, 0x7e, 0x77, 0xe1, 0xa8, 0xfd, 0xe9, 0x8b, 0x5d, + 0xeb, 0xb3, 0x17, 0xbb, 0xd6, 0x97, 0x2f, 0x76, 0xad, 0x4f, 0x5e, 0xee, 0x2e, 0x7c, 0xf6, 0x72, + 0x77, 0xe1, 0x1f, 0x2f, 0x77, 0x17, 0x3e, 0x72, 0x06, 0x54, 0x0c, 0x47, 0x7d, 0xdb, 0x67, 0x91, + 0x43, 0xc2, 0x90, 0xc6, 0x7d, 0x2a, 0xb8, 0xa3, 0xfe, 0x8b, 0xb8, 0x70, 0x5e, 0xfd, 0x93, 0x47, + 0x4c, 0x12, 0xe0, 0xfd, 0x25, 0x15, 0xfa, 0x6f, 0xfd, 0x37, 0x00, 0x00, 0xff, 0xff, 0xa4, 0xc5, + 0x73, 0xec, 0x02, 0x12, 0x00, 0x00, } func (m *Params) Marshal() (dAtA []byte, err error) { @@ -2081,6 +2095,13 @@ func (m *PendingDowntimeSlash) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if len(m.ConsumerConsAddr) > 0 { + i -= len(m.ConsumerConsAddr) + copy(dAtA[i:], m.ConsumerConsAddr) + i = encodeVarintProvider(dAtA, i, uint64(len(m.ConsumerConsAddr))) + i-- + dAtA[i] = 0x4a + } n20, err20 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.MaturesAt, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.MaturesAt):]) if err20 != nil { return 0, err20 @@ -2613,6 +2634,10 @@ func (m *PendingDowntimeSlash) Size() (n int) { n += 1 + l + sovProvider(uint64(l)) l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.MaturesAt) n += 1 + l + sovProvider(uint64(l)) + l = len(m.ConsumerConsAddr) + if l > 0 { + n += 1 + l + sovProvider(uint64(l)) + } return n } @@ -4902,6 +4927,40 @@ func (m *PendingDowntimeSlash) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ConsumerConsAddr", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowProvider + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthProvider + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthProvider + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ConsumerConsAddr = append(m.ConsumerConsAddr[:0], dAtA[iNdEx:postIndex]...) + if m.ConsumerConsAddr == nil { + m.ConsumerConsAddr = []byte{} + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipProvider(dAtA[iNdEx:]) diff --git a/x/vaas/provider/types/query.pb.go b/x/vaas/provider/types/query.pb.go index e89037e2..1952977e 100644 --- a/x/vaas/provider/types/query.pb.go +++ b/x/vaas/provider/types/query.pb.go @@ -691,6 +691,10 @@ var xxx_messageInfo_QueryParamsRequest proto.InternalMessageInfo type QueryParamsResponse struct { Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"` + // The infraction parameters, stored separately from params and updated by + // their own governance message (MsgUpdateInfractionParams), so a proposer + // can read the values in force before proposing a change. + InfractionParameters InfractionParameters `protobuf:"bytes,2,opt,name=infraction_parameters,json=infractionParameters,proto3" json:"infraction_parameters"` } func (m *QueryParamsResponse) Reset() { *m = QueryParamsResponse{} } @@ -733,6 +737,13 @@ func (m *QueryParamsResponse) GetParams() Params { return Params{} } +func (m *QueryParamsResponse) GetInfractionParameters() InfractionParameters { + if m != nil { + return m.InfractionParameters + } + return InfractionParameters{} +} + type QueryConsumerValidatorsRequest struct { ConsumerId uint64 `protobuf:"varint,1,opt,name=consumer_id,json=consumerId,proto3" json:"consumer_id,omitempty"` } @@ -2139,162 +2150,164 @@ func init() { func init() { proto.RegisterFile("vaas/provider/v1/query.proto", fileDescriptor_71b3f55ed407aa51) } var fileDescriptor_71b3f55ed407aa51 = []byte{ - // 2477 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x5a, 0x4f, 0x8c, 0x14, 0x59, - 0x19, 0x9f, 0x9a, 0x65, 0x86, 0xe6, 0x0d, 0xcc, 0xe2, 0x73, 0x70, 0x7a, 0x1a, 0x98, 0x86, 0x62, - 0x61, 0x59, 0x60, 0xaa, 0x98, 0xe6, 0x4f, 0x36, 0x88, 0x20, 0xd3, 0x30, 0x38, 0x61, 0x57, 0xda, - 0x02, 0xd7, 0x64, 0x13, 0xad, 0xbc, 0xe9, 0x7a, 0x74, 0x3f, 0xbb, 0xba, 0xaa, 0xb6, 0xaa, 0xba, - 0x61, 0x24, 0x5c, 0x3c, 0x18, 0x0f, 0x6b, 0xb2, 0x89, 0x26, 0x9a, 0x78, 0xd9, 0x18, 0x4f, 0xfe, - 0x49, 0x3c, 0x10, 0x63, 0x8c, 0x5e, 0x8c, 0x87, 0x3d, 0x70, 0xd8, 0xb0, 0x97, 0x8d, 0x07, 0xd6, - 0x80, 0x31, 0x9e, 0x37, 0x7a, 0xd0, 0x83, 0x31, 0xf5, 0xea, 0x7b, 0xd5, 0x5d, 0xaf, 0xab, 0xba, - 0x6b, 0x58, 0x3c, 0xd1, 0xf5, 0xde, 0xf7, 0x7d, 0xef, 0xf7, 0x7d, 0xef, 0x7b, 0xdf, 0x3f, 0x06, - 0x1d, 0xe8, 0x13, 0x12, 0xe8, 0x9e, 0xef, 0xf6, 0x99, 0x45, 0x7d, 0xbd, 0xbf, 0xaa, 0xbf, 0xd3, - 0xa3, 0xfe, 0x96, 0xe6, 0xf9, 0x6e, 0xe8, 0xe2, 0xbd, 0xd1, 0xae, 0x26, 0x76, 0xb5, 0xfe, 0x6a, - 0xe5, 0x40, 0xcb, 0x75, 0x5b, 0x36, 0xd5, 0x89, 0xc7, 0x74, 0xe2, 0x38, 0x6e, 0x48, 0x42, 0xe6, - 0x3a, 0x41, 0x4c, 0x5f, 0x59, 0x68, 0xb9, 0x2d, 0x97, 0xff, 0xd4, 0xa3, 0x5f, 0xb0, 0x5a, 0x05, - 0x1e, 0xfe, 0xb5, 0xd9, 0xbb, 0xa3, 0x87, 0xac, 0x4b, 0x83, 0x90, 0x74, 0x3d, 0x20, 0x58, 0x96, - 0x09, 0xac, 0x9e, 0xcf, 0xe5, 0x8a, 0xfd, 0x11, 0x90, 0x2d, 0xea, 0xd0, 0x80, 0x89, 0x63, 0xab, - 0x23, 0xfb, 0x09, 0xe4, 0x98, 0xe0, 0x20, 0x27, 0xe8, 0xaf, 0xea, 0x41, 0x9b, 0xf8, 0xd4, 0x32, - 0x9b, 0xae, 0x13, 0xf4, 0xba, 0xc9, 0x36, 0x16, 0xdb, 0x77, 0x99, 0x4f, 0x61, 0xed, 0x40, 0x48, - 0x1d, 0x8b, 0xfa, 0x5d, 0xe6, 0x84, 0x7a, 0xd3, 0xdf, 0xf2, 0x42, 0x57, 0xef, 0xd0, 0x2d, 0x71, - 0xe2, 0x52, 0xd3, 0x0d, 0xba, 0x6e, 0x60, 0xc6, 0xba, 0xc6, 0x1f, 0x02, 0x6c, 0xfc, 0xa5, 0x6f, - 0x92, 0x80, 0xea, 0xfd, 0xd5, 0x4d, 0x1a, 0x92, 0x55, 0xbd, 0xe9, 0x32, 0xa1, 0xcc, 0x2b, 0xb0, - 0x1f, 0x84, 0xa4, 0xc3, 0x9c, 0x56, 0x42, 0x02, 0xdf, 0x40, 0x75, 0x62, 0x58, 0x0a, 0xbf, 0x92, - 0x84, 0xd0, 0x23, 0x2d, 0xe6, 0x0c, 0x99, 0x47, 0xbd, 0x84, 0xf6, 0x7f, 0x2d, 0xa2, 0xa8, 0x83, - 0x56, 0xd7, 0x63, 0xe3, 0x18, 0xf4, 0x9d, 0x1e, 0x0d, 0x42, 0x5c, 0x45, 0x73, 0x42, 0x5f, 0x93, - 0x59, 0x65, 0xe5, 0x90, 0x72, 0x7c, 0x87, 0x81, 0xc4, 0xd2, 0x86, 0xa5, 0xb6, 0xd1, 0x81, 0x6c, - 0xfe, 0xc0, 0x73, 0x9d, 0x80, 0xe2, 0xaf, 0xa0, 0x3d, 0x60, 0x6f, 0x33, 0x08, 0x49, 0x48, 0xb9, - 0x88, 0xb9, 0xda, 0x41, 0x8d, 0x7b, 0x47, 0x7f, 0x55, 0x93, 0x18, 0x6f, 0x45, 0x44, 0x6b, 0x3b, - 0x3e, 0x78, 0x52, 0x9d, 0x32, 0x76, 0xb7, 0x86, 0xd6, 0xd4, 0x9f, 0x2a, 0xa8, 0x92, 0x3a, 0xaa, - 0xde, 0x26, 0xcc, 0x49, 0x90, 0x9e, 0x43, 0x33, 0x5e, 0x9b, 0x04, 0xf1, 0x01, 0xf3, 0xb5, 0xaa, - 0x26, 0xbb, 0x5f, 0x72, 0x52, 0x23, 0x22, 0x33, 0x62, 0x6a, 0xbc, 0x8e, 0xd0, 0xc0, 0x26, 0xe5, - 0x69, 0x0e, 0xee, 0x98, 0x06, 0x97, 0x12, 0x19, 0x50, 0x8b, 0x7d, 0x1a, 0x0c, 0xa8, 0x35, 0x48, - 0x8b, 0xc2, 0x91, 0xc6, 0x10, 0xa7, 0xfa, 0x63, 0x45, 0x32, 0xa4, 0x40, 0x07, 0x76, 0xd0, 0xd1, - 0x6c, 0x93, 0xaf, 0x94, 0x95, 0x43, 0x2f, 0x1d, 0x9f, 0xab, 0x2d, 0x66, 0xe0, 0x8b, 0xf6, 0x0d, - 0x20, 0xc3, 0xd7, 0x33, 0x80, 0xbd, 0x3a, 0x11, 0x58, 0x7c, 0x5a, 0x0a, 0xd9, 0xdf, 0x15, 0x34, - 0xc3, 0x45, 0xe3, 0x25, 0x54, 0xe2, 0xc2, 0xc5, 0x4d, 0xee, 0x32, 0x76, 0xf2, 0xef, 0x0d, 0x0b, - 0xef, 0x47, 0xbb, 0x9a, 0x36, 0xa3, 0x4e, 0x18, 0xed, 0x4d, 0xf3, 0xbd, 0x52, 0xbc, 0xb0, 0x61, - 0xe1, 0x05, 0x61, 0xda, 0x97, 0xf8, 0x06, 0x58, 0xee, 0x2a, 0x2a, 0x75, 0x69, 0x48, 0x2c, 0x12, - 0x92, 0xf2, 0x0e, 0x0e, 0x4f, 0xcd, 0xb7, 0xf9, 0x9b, 0x40, 0x09, 0x37, 0x9b, 0x70, 0xca, 0x0e, - 0x36, 0x23, 0x3b, 0x18, 0x3e, 0x8e, 0xf6, 0xde, 0xa1, 0xd4, 0xf4, 0x5c, 0xd7, 0x36, 0x89, 0x65, - 0xf9, 0x34, 0x08, 0xca, 0xb3, 0x1c, 0xc7, 0xfc, 0x1d, 0x4a, 0x1b, 0xae, 0x6b, 0x5f, 0x89, 0x57, - 0xd5, 0x1f, 0x28, 0xe8, 0x30, 0xbf, 0x82, 0xb7, 0x88, 0xcd, 0x2c, 0x12, 0xba, 0xbe, 0x38, 0x3d, - 0xa2, 0x10, 0x7e, 0xf2, 0x25, 0xb4, 0x57, 0x00, 0x4c, 0xe4, 0x71, 0x63, 0xac, 0xe1, 0x4f, 0x9f, - 0x54, 0xe7, 0xb7, 0x48, 0xd7, 0xbe, 0xa0, 0xc2, 0x86, 0x6a, 0xbc, 0x2c, 0x68, 0xe1, 0x10, 0x19, - 0xef, 0xb4, 0x8c, 0xf7, 0x42, 0xe9, 0xfb, 0xef, 0x57, 0xa7, 0xfe, 0xf1, 0x7e, 0x75, 0x4a, 0xbd, - 0x89, 0xd4, 0x71, 0x70, 0xc0, 0x31, 0x5e, 0x43, 0x7b, 0x13, 0x81, 0x29, 0x3c, 0xc6, 0xcb, 0xcd, - 0x21, 0xfa, 0x6c, 0x05, 0x1b, 0x43, 0xe8, 0x86, 0x14, 0xcc, 0x16, 0x98, 0xad, 0xa0, 0x74, 0xc8, - 0x67, 0x52, 0x30, 0x0d, 0x67, 0xa0, 0x60, 0xb6, 0xc1, 0x47, 0x8c, 0xab, 0xbe, 0x81, 0x5e, 0xe3, - 0x02, 0xaf, 0xd8, 0x76, 0x83, 0x30, 0x3f, 0x78, 0x8b, 0xd8, 0x91, 0xcd, 0xa2, 0xed, 0xb5, 0xe4, - 0x61, 0x15, 0x0e, 0x4d, 0xef, 0x2a, 0xe8, 0x44, 0x11, 0x71, 0x80, 0xf3, 0x5b, 0xe8, 0x73, 0x1e, - 0x61, 0xbe, 0xd9, 0x27, 0x76, 0x14, 0xe3, 0x39, 0x56, 0x78, 0xac, 0x67, 0x46, 0x1d, 0x3b, 0x12, - 0x18, 0xcb, 0x8b, 0xc4, 0x25, 0x8a, 0x3b, 0x56, 0x22, 0x77, 0xde, 0x4b, 0x91, 0xa8, 0xff, 0x54, - 0xd0, 0xe1, 0x89, 0x5c, 0x78, 0x3d, 0xd7, 0x3d, 0xf7, 0x7f, 0xfa, 0xa4, 0xba, 0x18, 0xdf, 0x9e, - 0x4c, 0x91, 0xe1, 0xa7, 0xeb, 0x19, 0x5e, 0x30, 0x2d, 0xcb, 0x91, 0x29, 0x32, 0xdc, 0xe1, 0x32, - 0xda, 0x9d, 0x50, 0x75, 0xe8, 0x16, 0x0f, 0x01, 0x73, 0xb5, 0x03, 0xda, 0x20, 0xc3, 0x69, 0x71, - 0x86, 0xd3, 0x1a, 0xbd, 0x4d, 0x9b, 0x35, 0x6f, 0xd0, 0x2d, 0x23, 0xb9, 0x97, 0x1b, 0x74, 0x4b, - 0x5d, 0x40, 0x98, 0x5f, 0x42, 0x83, 0xf8, 0xa4, 0x2b, 0xa2, 0xb5, 0xfa, 0x26, 0xfa, 0x7c, 0x6a, - 0x15, 0xee, 0xe0, 0x3c, 0x9a, 0xf5, 0xf8, 0x0a, 0xa4, 0x89, 0x72, 0x96, 0xe1, 0xa3, 0x7d, 0x88, - 0x23, 0x40, 0xad, 0x5e, 0x41, 0xcb, 0xa9, 0xe0, 0x9b, 0x78, 0x64, 0xf1, 0x44, 0xf6, 0xdf, 0x1d, - 0xe8, 0x50, 0x8e, 0x8c, 0xe4, 0xd7, 0x67, 0x0d, 0x1e, 0xb2, 0x31, 0xa7, 0xb7, 0x69, 0x4c, 0x7c, - 0x14, 0xcd, 0x27, 0x02, 0x3c, 0xf7, 0x2e, 0xf5, 0xf9, 0x7d, 0xbc, 0x64, 0xec, 0x11, 0xab, 0x8d, - 0x68, 0x11, 0xdf, 0x40, 0x73, 0x16, 0x0d, 0x9a, 0x3e, 0xf3, 0x78, 0xf2, 0x88, 0xa3, 0xf3, 0x11, - 0x91, 0x3c, 0x44, 0xb1, 0x20, 0x32, 0xc7, 0xd5, 0x01, 0x29, 0x98, 0x75, 0x98, 0x1b, 0x7f, 0x13, - 0x2d, 0x25, 0x3a, 0xbb, 0x1e, 0xf5, 0x23, 0x43, 0x24, 0xca, 0xcf, 0x70, 0xe5, 0x0f, 0x3f, 0x7e, - 0xb8, 0x72, 0x10, 0xa4, 0x27, 0xc6, 0x02, 0xa5, 0x6f, 0x85, 0x3e, 0x73, 0x5a, 0xc6, 0xa2, 0x90, - 0x71, 0x13, 0x44, 0x08, 0x9b, 0x7c, 0x01, 0xcd, 0x7e, 0x9b, 0x30, 0x9b, 0x5a, 0x3c, 0xaa, 0x97, - 0x0c, 0xf8, 0xc2, 0x17, 0xd0, 0x6c, 0x54, 0x30, 0xf4, 0x82, 0xf2, 0x4e, 0x9e, 0xd0, 0xd5, 0x3c, - 0xf8, 0x6b, 0xae, 0x63, 0xdd, 0xe2, 0x94, 0x06, 0x70, 0xe0, 0xdb, 0x28, 0x31, 0xbd, 0x19, 0xba, - 0x1d, 0xea, 0x04, 0xe5, 0x12, 0x07, 0x7a, 0x32, 0x52, 0xef, 0x2f, 0x4f, 0xaa, 0xfb, 0x62, 0x59, - 0x81, 0xd5, 0xd1, 0x98, 0xab, 0x77, 0x49, 0xd8, 0xd6, 0x36, 0x9c, 0xf0, 0xf1, 0xc3, 0x15, 0x04, - 0x87, 0x6c, 0x38, 0xa1, 0x31, 0x2f, 0x64, 0xdc, 0xe6, 0x22, 0x22, 0xe3, 0x27, 0x52, 0x63, 0xe3, - 0xef, 0x8a, 0x8d, 0x2f, 0x56, 0x63, 0xe3, 0x9f, 0x47, 0x8b, 0xfd, 0xd8, 0x06, 0x34, 0x30, 0x9b, - 0x3d, 0xdf, 0x8f, 0xb2, 0x2a, 0xf5, 0xdc, 0x66, 0xbb, 0x8c, 0xb8, 0x86, 0xfb, 0x92, 0xed, 0x7a, - 0xbc, 0x7b, 0x2d, 0xda, 0x54, 0x7b, 0xa8, 0x9a, 0xeb, 0xc3, 0xf0, 0x3c, 0x0c, 0x84, 0xfa, 0xc9, - 0x2a, 0xc4, 0xa6, 0xda, 0xe8, 0x13, 0x99, 0xe4, 0xc6, 0xc6, 0x90, 0x14, 0x55, 0x05, 0xb7, 0x5f, - 0xb3, 0xdd, 0x66, 0x27, 0xf8, 0xba, 0x13, 0x32, 0xfb, 0xab, 0xf4, 0x5e, 0x8c, 0x49, 0xbc, 0xd6, - 0xb7, 0x21, 0xef, 0x64, 0xd3, 0x00, 0xb8, 0x73, 0x68, 0x71, 0x93, 0xef, 0x9b, 0xbd, 0x88, 0xc0, - 0x74, 0xe8, 0x3d, 0xa1, 0x77, 0xfc, 0xda, 0x16, 0x36, 0x33, 0xd8, 0xd5, 0x2b, 0x90, 0x44, 0xea, - 0xc9, 0x53, 0x5c, 0xf7, 0xdd, 0x6e, 0x1d, 0x6a, 0x0f, 0xf1, 0x7c, 0x53, 0xf5, 0x89, 0x92, 0xae, - 0x4f, 0xd4, 0x75, 0x74, 0x64, 0xac, 0x08, 0x00, 0x38, 0x31, 0x04, 0x5c, 0x44, 0x4b, 0xa3, 0x25, - 0x5c, 0xe1, 0x00, 0xf2, 0xaf, 0xe9, 0xac, 0xfa, 0xb4, 0xf0, 0xe9, 0xa9, 0xea, 0x6c, 0x3a, 0x5d, - 0x9d, 0x1d, 0x41, 0x7b, 0xdc, 0xbb, 0xce, 0x50, 0xcc, 0x89, 0x0b, 0xb1, 0xdd, 0x7c, 0x51, 0x3c, - 0xa4, 0xa4, 0x4a, 0xdb, 0x91, 0x57, 0xa5, 0xcd, 0x3c, 0x77, 0x95, 0x76, 0x0b, 0xcd, 0x31, 0x87, - 0x85, 0x26, 0x04, 0xe7, 0x59, 0x2e, 0xa8, 0x96, 0x2f, 0x68, 0xc3, 0x61, 0x21, 0x23, 0x36, 0xfb, - 0x0e, 0x2f, 0x41, 0x79, 0xc8, 0xa6, 0x21, 0xf5, 0x03, 0x03, 0x45, 0x62, 0xe2, 0x10, 0x9e, 0xbe, - 0xd3, 0x9d, 0x52, 0xcd, 0x99, 0x55, 0xf6, 0x95, 0x32, 0xcb, 0xbe, 0x35, 0xe9, 0xdd, 0x40, 0x23, - 0x71, 0x9b, 0x75, 0x69, 0xe1, 0xbb, 0xeb, 0x48, 0xb1, 0x3f, 0x25, 0x03, 0x2e, 0xf0, 0x3a, 0x12, - 0xfd, 0x88, 0x19, 0xf5, 0xa0, 0x90, 0xa1, 0x2a, 0x5a, 0xdc, 0x7f, 0x6a, 0xa2, 0xff, 0xd4, 0x6e, - 0x8b, 0x06, 0x75, 0xad, 0x14, 0x59, 0xf1, 0xbd, 0x4f, 0xaa, 0x8a, 0x31, 0xd7, 0x1a, 0x08, 0x54, - 0xeb, 0xd2, 0x61, 0xeb, 0x94, 0x06, 0x0d, 0xea, 0xf3, 0xc7, 0x55, 0x18, 0xf1, 0x6f, 0x45, 0x2d, - 0x98, 0x2d, 0x05, 0x30, 0x7b, 0x28, 0xb2, 0x56, 0x60, 0x7a, 0xd4, 0x37, 0xf9, 0xeb, 0x03, 0xd4, - 0x4b, 0xa9, 0x46, 0x42, 0x44, 0xd2, 0xba, 0xcb, 0x9c, 0x35, 0x3d, 0x02, 0xfd, 0x9f, 0x27, 0xd5, - 0x57, 0x5b, 0x2c, 0x6c, 0xf7, 0x36, 0xb5, 0xa6, 0xdb, 0x85, 0x1e, 0x15, 0xfe, 0x59, 0x09, 0xac, - 0x8e, 0x1e, 0x6e, 0x79, 0x34, 0xe0, 0x0c, 0xc6, 0xee, 0x3b, 0x43, 0x27, 0x47, 0xc0, 0x59, 0x60, - 0xba, 0x7d, 0xea, 0xfb, 0xcc, 0xa2, 0xdc, 0x91, 0x4b, 0x06, 0x62, 0xc1, 0x4d, 0x58, 0x51, 0xfb, - 0xe8, 0x94, 0x28, 0xca, 0xb2, 0xa0, 0x0b, 0xba, 0x24, 0x71, 0xa7, 0x1b, 0x34, 0xe5, 0xb9, 0x1b, - 0xb4, 0x47, 0x0a, 0x5a, 0x29, 0x78, 0x70, 0x12, 0x6d, 0x77, 0x09, 0x3d, 0x44, 0xb0, 0xd5, 0xf2, - 0x5d, 0x3e, 0x4b, 0x16, 0xbc, 0xa3, 0x81, 0x98, 0x17, 0xd7, 0xd5, 0xdd, 0x1f, 0x75, 0xa2, 0xe8, - 0x51, 0xd4, 0x6d, 0xc2, 0xba, 0x45, 0x9d, 0x08, 0x9f, 0x47, 0xbb, 0x2c, 0xea, 0xb9, 0x01, 0x0b, - 0x5d, 0x1f, 0xaa, 0xc3, 0xf2, 0xe3, 0x87, 0x2b, 0x0b, 0x80, 0x27, 0x9d, 0xc1, 0x07, 0xa4, 0xea, - 0xf7, 0x32, 0x9c, 0x6f, 0xe8, 0x74, 0xb0, 0x1f, 0x41, 0x33, 0xcd, 0x68, 0x01, 0x6c, 0x37, 0xc6, - 0xe7, 0x4e, 0x47, 0x66, 0xfa, 0xc5, 0x27, 0xd5, 0xe3, 0x05, 0x7d, 0x2e, 0x30, 0x62, 0xc9, 0xea, - 0x2f, 0x15, 0x34, 0x7f, 0x55, 0xc0, 0xe2, 0xa7, 0xa7, 0x75, 0x52, 0x0a, 0xeb, 0x34, 0x40, 0x3b, - 0xfd, 0x7f, 0x43, 0xfb, 0xee, 0x38, 0xb3, 0x15, 0xae, 0x54, 0x5f, 0xd8, 0xc8, 0xe2, 0xd7, 0x8a, - 0x94, 0x7a, 0x25, 0x38, 0x70, 0x8d, 0x97, 0xd0, 0x2c, 0x87, 0x2f, 0xde, 0xc0, 0xa1, 0xd1, 0x37, - 0x90, 0xbe, 0x02, 0x51, 0x9b, 0xc7, 0x5c, 0x2f, 0xce, 0xe5, 0x2f, 0x4b, 0xa3, 0xa6, 0x37, 0x58, - 0x3f, 0x8a, 0xaa, 0xc5, 0x4b, 0xfc, 0x1f, 0x4d, 0xa3, 0x83, 0x39, 0x12, 0x06, 0xd3, 0x2a, 0x9b, - 0x04, 0xa1, 0x49, 0x9a, 0x9d, 0xe7, 0x08, 0xf2, 0x11, 0xeb, 0x95, 0x66, 0x27, 0xda, 0xc3, 0xeb, - 0x68, 0x77, 0xcb, 0x27, 0x4d, 0x1a, 0x85, 0x5e, 0xe6, 0x5a, 0xa0, 0xf7, 0xd2, 0x88, 0xa0, 0xab, - 0x30, 0xad, 0x8c, 0xe5, 0xfc, 0x24, 0x4e, 0x16, 0x11, 0x63, 0x83, 0xf3, 0xe1, 0x6b, 0x68, 0xce, - 0xa7, 0x5d, 0x37, 0x6a, 0x4a, 0x69, 0x48, 0xa0, 0xfd, 0x2a, 0x86, 0x07, 0x01, 0xe3, 0xb5, 0x90, - 0xe0, 0x0a, 0x2a, 0x59, 0xb4, 0xe5, 0x13, 0x8b, 0x5a, 0xbc, 0x3e, 0x28, 0x19, 0xc9, 0xb7, 0x7a, - 0x0d, 0xdc, 0xa0, 0x41, 0x1d, 0x8b, 0x39, 0xad, 0xab, 0xee, 0x5d, 0x27, 0xd2, 0xfd, 0x96, 0x4d, - 0x82, 0x36, 0x2d, 0x6e, 0xdd, 0x2e, 0x54, 0x61, 0x79, 0x62, 0xc0, 0xc4, 0xeb, 0x68, 0x67, 0x10, - 0x2f, 0x81, 0x3f, 0x1d, 0xcb, 0xe8, 0xf1, 0x32, 0x44, 0x80, 0x57, 0x09, 0xe6, 0xa4, 0xe5, 0xfb, - 0x06, 0x0b, 0xdb, 0x6d, 0x6a, 0x5b, 0xeb, 0x94, 0x1a, 0xb4, 0xe9, 0xfa, 0x56, 0x71, 0xc4, 0x77, - 0xa0, 0x72, 0xc8, 0x12, 0x01, 0x68, 0xeb, 0x68, 0xa7, 0x1f, 0x2f, 0x01, 0xda, 0x23, 0xa3, 0x68, - 0x47, 0xd8, 0x05, 0x54, 0xe0, 0xac, 0xfd, 0xbb, 0x82, 0x66, 0xf8, 0x41, 0xf8, 0x57, 0x0a, 0x5a, - 0xc8, 0x2a, 0x34, 0xf0, 0xca, 0x84, 0x2a, 0x3e, 0x3d, 0x96, 0xad, 0x68, 0x45, 0xc9, 0x63, 0x35, - 0xd4, 0x73, 0xdf, 0xfd, 0xe8, 0x6f, 0x3f, 0x9c, 0xd6, 0xf1, 0x8a, 0x9e, 0x9e, 0x76, 0x27, 0xf6, - 0x81, 0xfa, 0x44, 0xbf, 0x3f, 0x64, 0xb1, 0x07, 0xf8, 0x67, 0x0a, 0xb4, 0xe9, 0xe9, 0xa1, 0x26, - 0x3e, 0x35, 0xe1, 0xf8, 0xd4, 0x64, 0xb6, 0xb2, 0x52, 0x90, 0x1a, 0xb0, 0x6a, 0x1c, 0xeb, 0x71, - 0x7c, 0x2c, 0x0f, 0x6b, 0x3c, 0x20, 0xd5, 0xef, 0xf3, 0x02, 0xf7, 0x01, 0xfe, 0x58, 0xcc, 0x85, - 0x33, 0xe7, 0x6c, 0xf8, 0x4c, 0xce, 0xe9, 0xe3, 0x86, 0x84, 0x95, 0xb3, 0xdb, 0x63, 0x02, 0xe4, - 0x37, 0x39, 0xf2, 0x0d, 0x7c, 0x5d, 0x42, 0x9e, 0x74, 0x5b, 0x66, 0x6a, 0xe0, 0x92, 0x36, 0xb6, - 0x7e, 0x5f, 0x9e, 0x2c, 0x64, 0xa9, 0x36, 0x3c, 0x61, 0x9b, 0xac, 0x5a, 0xc6, 0x78, 0x70, 0xb2, - 0x6a, 0x59, 0x43, 0xbc, 0x02, 0xaa, 0xa5, 0xd0, 0xcb, 0xaa, 0xc9, 0x83, 0xa6, 0x07, 0xf8, 0x23, - 0x91, 0x7c, 0xc6, 0x0e, 0xe7, 0xf0, 0x17, 0x73, 0xd0, 0x16, 0x99, 0x10, 0x56, 0x2e, 0x3e, 0x1f, - 0x33, 0xa8, 0x5c, 0xe3, 0x2a, 0x9f, 0xc2, 0x27, 0x24, 0x95, 0x41, 0x05, 0xd3, 0x8b, 0x44, 0x48, - 0x0f, 0x66, 0x0b, 0xcd, 0x0d, 0x8d, 0xb5, 0xf0, 0x2b, 0x39, 0x00, 0x52, 0xb3, 0xb0, 0xca, 0xd1, - 0x09, 0x54, 0x80, 0xe7, 0x20, 0xc7, 0xb3, 0x88, 0xf7, 0x49, 0x78, 0xe2, 0x9e, 0x0c, 0xff, 0x4e, - 0x41, 0x8b, 0x39, 0x8d, 0x3f, 0x3e, 0x5d, 0x78, 0x46, 0x20, 0x30, 0xad, 0x6e, 0x83, 0x03, 0xf0, - 0xbd, 0xce, 0xf1, 0xd5, 0xf0, 0xe9, 0xbc, 0x77, 0x3b, 0x18, 0x3a, 0x48, 0x56, 0x7b, 0xa8, 0x40, - 0xe3, 0x9d, 0x35, 0x5f, 0xc0, 0x79, 0x03, 0x8e, 0x31, 0x03, 0x8b, 0xca, 0x99, 0x6d, 0xf1, 0x4c, - 0x08, 0x3c, 0x39, 0x53, 0x0d, 0xfc, 0x7b, 0xf9, 0xbf, 0x7c, 0xd2, 0x73, 0x07, 0x7c, 0x76, 0x82, - 0x0d, 0x33, 0x27, 0x1d, 0x95, 0x73, 0xdb, 0xe4, 0x2a, 0x1a, 0x35, 0x99, 0xa5, 0xdf, 0x4f, 0xda, - 0xed, 0x07, 0xf8, 0xe7, 0x0a, 0xcc, 0x65, 0x53, 0x51, 0x18, 0x9f, 0x2c, 0x12, 0xab, 0x05, 0xd4, - 0x53, 0xc5, 0x88, 0x01, 0xe1, 0x19, 0x8e, 0x70, 0x05, 0x9f, 0x1c, 0x1b, 0xd7, 0x25, 0xd7, 0xf8, - 0xa3, 0x82, 0xca, 0x79, 0x9d, 0x39, 0x5e, 0x2d, 0x96, 0x05, 0x87, 0x26, 0x01, 0x95, 0xda, 0x76, - 0x58, 0x00, 0xf8, 0x05, 0x0e, 0xfc, 0x2c, 0xae, 0x4d, 0x48, 0x9e, 0xbc, 0x62, 0x94, 0xf0, 0xff, - 0x49, 0x91, 0x66, 0x4a, 0xc3, 0x6d, 0x22, 0x9e, 0x84, 0x26, 0x63, 0x32, 0x90, 0xeb, 0xda, 0xe3, - 0xe6, 0x00, 0xea, 0x45, 0xae, 0xc2, 0x79, 0x7c, 0x36, 0x4f, 0x85, 0xf4, 0x94, 0x40, 0x52, 0xe2, - 0xa9, 0x82, 0x8e, 0x16, 0x6a, 0x9d, 0xf1, 0xa5, 0xfc, 0x88, 0x5b, 0xa4, 0xd9, 0xaf, 0x5c, 0x7e, - 0x6e, 0xfe, 0xa2, 0x41, 0x28, 0xad, 0xa8, 0x39, 0xe8, 0xcc, 0x1f, 0x29, 0x68, 0x21, 0xab, 0x11, - 0x2a, 0x72, 0x49, 0x72, 0xe7, 0x5d, 0xe4, 0x92, 0x46, 0xfa, 0x65, 0xf5, 0x06, 0xc7, 0x7e, 0x0d, - 0xd7, 0xf5, 0x91, 0x3f, 0x49, 0x18, 0x86, 0x1f, 0xcf, 0xc4, 0x78, 0x73, 0x25, 0xa7, 0xd9, 0xa4, - 0x9b, 0x7d, 0x80, 0xff, 0xac, 0xa0, 0x7d, 0x99, 0x7d, 0x1d, 0xde, 0x0e, 0xb6, 0x60, 0x52, 0xd5, - 0x30, 0xb6, 0x75, 0x54, 0xbf, 0xcc, 0x35, 0xba, 0x80, 0x5f, 0x2f, 0xac, 0x91, 0x9c, 0x1a, 0x7e, - 0xa3, 0xa0, 0x7d, 0x99, 0x2d, 0x1b, 0x9e, 0x54, 0x02, 0x4b, 0xdd, 0x61, 0x45, 0x2f, 0x4c, 0x0f, - 0xe0, 0xcf, 0x73, 0xf0, 0xa7, 0xb1, 0x96, 0xe7, 0x4a, 0x36, 0x70, 0x48, 0x90, 0x1f, 0x89, 0xb4, - 0x90, 0xdd, 0x08, 0xe5, 0xa6, 0x85, 0xb1, 0xed, 0x57, 0x6e, 0x5a, 0x18, 0xdf, 0x6d, 0x8d, 0xbb, - 0x01, 0x2f, 0xe6, 0x34, 0x2d, 0x60, 0x35, 0xa1, 0xb3, 0x92, 0xd4, 0xf9, 0x83, 0xa8, 0x2b, 0x46, - 0xbb, 0xa4, 0xdc, 0xba, 0x22, 0xb7, 0x27, 0xcb, 0xad, 0x2b, 0xf2, 0x5b, 0xb0, 0xdc, 0xd8, 0xc5, - 0xff, 0xe4, 0x26, 0xe6, 0xe2, 0x4e, 0x04, 0xdd, 0x56, 0x1a, 0xfe, 0xda, 0xc6, 0x07, 0x4f, 0x97, - 0x95, 0x0f, 0x9f, 0x2e, 0x2b, 0x7f, 0x7d, 0xba, 0xac, 0xbc, 0xf7, 0x6c, 0x79, 0xea, 0xc3, 0x67, - 0xcb, 0x53, 0x1f, 0x3f, 0x5b, 0x9e, 0x7a, 0x5b, 0x1f, 0x1a, 0xdf, 0x10, 0xdb, 0x66, 0xce, 0x26, - 0x0b, 0x83, 0xf8, 0x8c, 0x7b, 0xd2, 0x51, 0x7c, 0x96, 0xb3, 0x39, 0xcb, 0xbb, 0xed, 0x33, 0xff, - 0x0b, 0x00, 0x00, 0xff, 0xff, 0x63, 0x00, 0xce, 0x5a, 0xf7, 0x24, 0x00, 0x00, + // 2502 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x5a, 0x4d, 0x6c, 0x1c, 0x49, + 0x15, 0x76, 0x3b, 0xb1, 0x33, 0x29, 0x27, 0xde, 0x50, 0xd8, 0x78, 0x3c, 0x49, 0x3c, 0x49, 0x67, + 0xb3, 0x9b, 0x4d, 0xe2, 0xee, 0x78, 0xf2, 0xa3, 0x55, 0x08, 0x09, 0xb1, 0x13, 0x07, 0x2b, 0x0b, + 0x19, 0x3a, 0x61, 0x91, 0x56, 0x82, 0x56, 0x79, 0xba, 0x3c, 0x53, 0x4c, 0x4f, 0x77, 0x6f, 0x77, + 0xcf, 0x24, 0x26, 0xca, 0x85, 0x03, 0xe2, 0xb0, 0x48, 0x2b, 0x81, 0x04, 0x12, 0x97, 0x15, 0xe2, + 0xc4, 0x8f, 0xb4, 0x87, 0x08, 0x21, 0x04, 0x17, 0xc4, 0x61, 0x0f, 0x39, 0xac, 0xb2, 0x97, 0x15, + 0x87, 0x2c, 0x4a, 0x10, 0xe2, 0xbc, 0x82, 0x03, 0x1c, 0x10, 0xaa, 0xea, 0x57, 0x3d, 0xd3, 0x3d, + 0xdd, 0x33, 0xed, 0x6c, 0x38, 0x65, 0xba, 0xea, 0xbd, 0x57, 0xdf, 0x7b, 0xf5, 0xea, 0xfd, 0xc5, + 0xe8, 0x50, 0x8f, 0x90, 0x40, 0xf7, 0x7c, 0xb7, 0xc7, 0x2c, 0xea, 0xeb, 0xbd, 0x15, 0xfd, 0xed, + 0x2e, 0xf5, 0xb7, 0x35, 0xcf, 0x77, 0x43, 0x17, 0x1f, 0xe0, 0xbb, 0x9a, 0xdc, 0xd5, 0x7a, 0x2b, + 0x95, 0x43, 0x4d, 0xd7, 0x6d, 0xda, 0x54, 0x27, 0x1e, 0xd3, 0x89, 0xe3, 0xb8, 0x21, 0x09, 0x99, + 0xeb, 0x04, 0x11, 0x7d, 0x65, 0xae, 0xe9, 0x36, 0x5d, 0xf1, 0x53, 0xe7, 0xbf, 0x60, 0xb5, 0x0a, + 0x3c, 0xe2, 0x6b, 0xb3, 0xbb, 0xa5, 0x87, 0xac, 0x43, 0x83, 0x90, 0x74, 0x3c, 0x20, 0x58, 0x4a, + 0x13, 0x58, 0x5d, 0x5f, 0xc8, 0x95, 0xfb, 0x43, 0x20, 0x9b, 0xd4, 0xa1, 0x01, 0x93, 0xc7, 0x56, + 0x87, 0xf6, 0x63, 0xc8, 0x11, 0xc1, 0x61, 0x41, 0xd0, 0x5b, 0xd1, 0x83, 0x16, 0xf1, 0xa9, 0x65, + 0x36, 0x5c, 0x27, 0xe8, 0x76, 0xe2, 0x6d, 0x2c, 0xb7, 0xef, 0x32, 0x9f, 0xc2, 0xda, 0xa1, 0x90, + 0x3a, 0x16, 0xf5, 0x3b, 0xcc, 0x09, 0xf5, 0x86, 0xbf, 0xed, 0x85, 0xae, 0xde, 0xa6, 0xdb, 0xf2, + 0xc4, 0xc5, 0x86, 0x1b, 0x74, 0xdc, 0xc0, 0x8c, 0x74, 0x8d, 0x3e, 0x24, 0xd8, 0xe8, 0x4b, 0xdf, + 0x24, 0x01, 0xd5, 0x7b, 0x2b, 0x9b, 0x34, 0x24, 0x2b, 0x7a, 0xc3, 0x65, 0x52, 0x99, 0x97, 0x61, + 0x3f, 0x08, 0x49, 0x9b, 0x39, 0xcd, 0x98, 0x04, 0xbe, 0x81, 0xea, 0xe4, 0xa0, 0x14, 0x71, 0x25, + 0x31, 0xa1, 0x47, 0x9a, 0xcc, 0x19, 0x30, 0x8f, 0x7a, 0x19, 0x1d, 0xfc, 0x3a, 0xa7, 0x58, 0x03, + 0xad, 0x6e, 0x44, 0xc6, 0x31, 0xe8, 0xdb, 0x5d, 0x1a, 0x84, 0xb8, 0x8a, 0x66, 0xa4, 0xbe, 0x26, + 0xb3, 0xca, 0xca, 0x11, 0xe5, 0xc4, 0x6e, 0x03, 0xc9, 0xa5, 0x0d, 0x4b, 0x6d, 0xa1, 0x43, 0xd9, + 0xfc, 0x81, 0xe7, 0x3a, 0x01, 0xc5, 0x5f, 0x41, 0xfb, 0xc1, 0xde, 0x66, 0x10, 0x92, 0x90, 0x0a, + 0x11, 0x33, 0xb5, 0xc3, 0x9a, 0xf0, 0x8e, 0xde, 0x8a, 0x96, 0x62, 0xbc, 0xcd, 0x89, 0x56, 0x77, + 0x7f, 0xf0, 0xa4, 0x3a, 0x61, 0xec, 0x6b, 0x0e, 0xac, 0xa9, 0x3f, 0x53, 0x50, 0x25, 0x71, 0xd4, + 0x5a, 0x8b, 0x30, 0x27, 0x46, 0x7a, 0x1e, 0x4d, 0x79, 0x2d, 0x12, 0x44, 0x07, 0xcc, 0xd6, 0xaa, + 0x5a, 0xda, 0xfd, 0xe2, 0x93, 0xea, 0x9c, 0xcc, 0x88, 0xa8, 0xf1, 0x3a, 0x42, 0x7d, 0x9b, 0x94, + 0x27, 0x05, 0xb8, 0x57, 0x34, 0xb8, 0x14, 0x6e, 0x40, 0x2d, 0xf2, 0x69, 0x30, 0xa0, 0x56, 0x27, + 0x4d, 0x0a, 0x47, 0x1a, 0x03, 0x9c, 0xea, 0x4f, 0x94, 0x94, 0x21, 0x25, 0x3a, 0xb0, 0x83, 0x8e, + 0xa6, 0x1b, 0x62, 0xa5, 0xac, 0x1c, 0xd9, 0x75, 0x62, 0xa6, 0xb6, 0x90, 0x81, 0x8f, 0xef, 0x1b, + 0x40, 0x86, 0x6f, 0x64, 0x00, 0x7b, 0x75, 0x2c, 0xb0, 0xe8, 0xb4, 0x04, 0xb2, 0xbf, 0x2b, 0x68, + 0x4a, 0x88, 0xc6, 0x8b, 0xa8, 0x24, 0x84, 0xcb, 0x9b, 0xdc, 0x6b, 0xec, 0x11, 0xdf, 0x1b, 0x16, + 0x3e, 0x88, 0xf6, 0x36, 0x6c, 0x46, 0x9d, 0x90, 0xef, 0x4d, 0x8a, 0xbd, 0x52, 0xb4, 0xb0, 0x61, + 0xe1, 0x39, 0x69, 0xda, 0x5d, 0x62, 0x03, 0x2c, 0x77, 0x0d, 0x95, 0x3a, 0x34, 0x24, 0x16, 0x09, + 0x49, 0x79, 0xb7, 0x80, 0xa7, 0xe6, 0xdb, 0xfc, 0xab, 0x40, 0x09, 0x37, 0x1b, 0x73, 0xa6, 0x1d, + 0x6c, 0x2a, 0xed, 0x60, 0xf8, 0x04, 0x3a, 0xb0, 0x45, 0xa9, 0xe9, 0xb9, 0xae, 0x6d, 0x12, 0xcb, + 0xf2, 0x69, 0x10, 0x94, 0xa7, 0x05, 0x8e, 0xd9, 0x2d, 0x4a, 0xeb, 0xae, 0x6b, 0x5f, 0x8d, 0x56, + 0xd5, 0x1f, 0x2a, 0xe8, 0xa8, 0xb8, 0x82, 0x37, 0x89, 0xcd, 0x2c, 0x12, 0xba, 0xbe, 0x3c, 0x9d, + 0x53, 0x48, 0x3f, 0xf9, 0x12, 0x3a, 0x20, 0x01, 0xc6, 0xf2, 0x84, 0x31, 0x56, 0xf1, 0xa7, 0x4f, + 0xaa, 0xb3, 0xdb, 0xa4, 0x63, 0x5f, 0x54, 0x61, 0x43, 0x35, 0x5e, 0x92, 0xb4, 0x70, 0x48, 0x1a, + 0xef, 0x64, 0x1a, 0xef, 0xc5, 0xd2, 0x0f, 0xde, 0xab, 0x4e, 0xfc, 0xe3, 0xbd, 0xea, 0x84, 0x7a, + 0x0b, 0xa9, 0xa3, 0xe0, 0x80, 0x63, 0xbc, 0x86, 0x0e, 0xc4, 0x02, 0x13, 0x78, 0x8c, 0x97, 0x1a, + 0x03, 0xf4, 0xd9, 0x0a, 0xd6, 0x07, 0xd0, 0x0d, 0x28, 0x98, 0x2d, 0x30, 0x5b, 0xc1, 0xd4, 0x21, + 0x9f, 0x49, 0xc1, 0x24, 0x9c, 0xbe, 0x82, 0xd9, 0x06, 0x1f, 0x32, 0xae, 0xfa, 0x06, 0x7a, 0x4d, + 0x08, 0xbc, 0x6a, 0xdb, 0x75, 0xc2, 0xfc, 0xe0, 0x4d, 0x62, 0x73, 0x9b, 0xf1, 0xed, 0xd5, 0xf8, + 0x61, 0x15, 0x0e, 0x4d, 0xef, 0x28, 0xe8, 0x64, 0x11, 0x71, 0x80, 0xf3, 0xdb, 0xe8, 0x73, 0x1e, + 0x61, 0xbe, 0xd9, 0x23, 0x36, 0x8f, 0xf1, 0x02, 0x2b, 0x3c, 0xd6, 0xb3, 0xc3, 0x8e, 0xcd, 0x05, + 0x46, 0xf2, 0xb8, 0xb8, 0x58, 0x71, 0xc7, 0x8a, 0xe5, 0xce, 0x7a, 0x09, 0x12, 0xf5, 0x9f, 0x0a, + 0x3a, 0x3a, 0x96, 0x0b, 0xaf, 0xe7, 0xba, 0xe7, 0xc1, 0x4f, 0x9f, 0x54, 0x17, 0xa2, 0xdb, 0x4b, + 0x53, 0x64, 0xf8, 0xe9, 0x7a, 0x86, 0x17, 0x4c, 0xa6, 0xe5, 0xa4, 0x29, 0x32, 0xdc, 0xe1, 0x0a, + 0xda, 0x17, 0x53, 0xb5, 0xe9, 0xb6, 0x08, 0x01, 0x33, 0xb5, 0x43, 0x5a, 0x3f, 0xc3, 0x69, 0x51, + 0x86, 0xd3, 0xea, 0xdd, 0x4d, 0x9b, 0x35, 0x6e, 0xd2, 0x6d, 0x23, 0xbe, 0x97, 0x9b, 0x74, 0x5b, + 0x9d, 0x43, 0x58, 0x5c, 0x42, 0x9d, 0xf8, 0xa4, 0x23, 0xa3, 0xb5, 0xfa, 0xbe, 0x82, 0x3e, 0x9f, + 0x58, 0x86, 0x4b, 0xb8, 0x80, 0xa6, 0x3d, 0xb1, 0x02, 0x79, 0xa2, 0x9c, 0x65, 0x79, 0xbe, 0x0f, + 0x81, 0x04, 0xa8, 0x31, 0x41, 0xf3, 0xcc, 0xd9, 0xf2, 0x49, 0x83, 0x87, 0x3c, 0x53, 0x2c, 0xd2, + 0x90, 0xfa, 0x41, 0x1c, 0xd1, 0x87, 0xc4, 0x6c, 0xc4, 0xe4, 0xf5, 0x98, 0x1a, 0x84, 0xce, 0xb1, + 0x8c, 0x3d, 0xf5, 0x2a, 0x5a, 0x4a, 0x04, 0xf8, 0xd8, 0xeb, 0x8b, 0x27, 0xcb, 0xff, 0xee, 0x46, + 0x47, 0x72, 0x64, 0xc4, 0xbf, 0x3e, 0x6b, 0x80, 0x4a, 0x5f, 0xd8, 0xe4, 0x0e, 0x2f, 0x0c, 0x1f, + 0x47, 0xb3, 0xb1, 0x00, 0xcf, 0xbd, 0x4b, 0x7d, 0x71, 0xe7, 0xbb, 0x8c, 0xfd, 0x72, 0xb5, 0xce, + 0x17, 0xf1, 0x4d, 0x34, 0x63, 0xd1, 0xa0, 0xe1, 0x33, 0x4f, 0x24, 0xa8, 0x28, 0x03, 0x1c, 0x93, + 0x09, 0x4a, 0x16, 0x24, 0x32, 0x3b, 0x5d, 0xeb, 0x93, 0x82, 0x91, 0x07, 0xb9, 0xf1, 0xb7, 0xd0, + 0x62, 0xac, 0xb3, 0xeb, 0x51, 0x9f, 0x1b, 0x22, 0x56, 0x7e, 0x4a, 0x28, 0x7f, 0xf4, 0xf1, 0xc3, + 0xe5, 0xc3, 0x20, 0x3d, 0x36, 0x16, 0x28, 0x7d, 0x3b, 0xf4, 0x99, 0xd3, 0x34, 0x16, 0xa4, 0x8c, + 0x5b, 0x20, 0x42, 0xda, 0xe4, 0x0b, 0x68, 0xfa, 0x3b, 0x84, 0xd9, 0xd4, 0x12, 0x99, 0xa3, 0x64, + 0xc0, 0x17, 0xbe, 0x88, 0xa6, 0x79, 0x51, 0xd2, 0x0d, 0xca, 0x7b, 0x44, 0xd1, 0xa0, 0xe6, 0xc1, + 0x5f, 0x75, 0x1d, 0xeb, 0xb6, 0xa0, 0x34, 0x80, 0x03, 0xdf, 0x41, 0xb1, 0xe9, 0xcd, 0xd0, 0x6d, + 0x53, 0x27, 0x28, 0x97, 0x04, 0xd0, 0x53, 0x5c, 0xbd, 0xbf, 0x3c, 0xa9, 0xce, 0x47, 0xb2, 0x02, + 0xab, 0xad, 0x31, 0x57, 0xef, 0x90, 0xb0, 0xa5, 0x6d, 0x38, 0xe1, 0xe3, 0x87, 0xcb, 0x08, 0x0e, + 0xd9, 0x70, 0x42, 0x63, 0x56, 0xca, 0xb8, 0x23, 0x44, 0x70, 0xe3, 0xc7, 0x52, 0x23, 0xe3, 0xef, + 0x8d, 0x8c, 0x2f, 0x57, 0x23, 0xe3, 0x5f, 0x40, 0x0b, 0xbd, 0xc8, 0x06, 0x34, 0x30, 0x1b, 0x5d, + 0xdf, 0xe7, 0x99, 0x9b, 0x7a, 0x6e, 0xa3, 0x55, 0x46, 0x42, 0xc3, 0xf9, 0x78, 0x7b, 0x2d, 0xda, + 0xbd, 0xce, 0x37, 0xd5, 0x2e, 0xaa, 0xe6, 0xfa, 0x30, 0xbc, 0x40, 0x03, 0xa1, 0x5e, 0xbc, 0x0a, + 0xf1, 0xaf, 0x36, 0xfc, 0x7c, 0xc6, 0xb9, 0xb1, 0x31, 0x20, 0x45, 0x55, 0xc1, 0xed, 0x57, 0x6d, + 0xb7, 0xd1, 0x0e, 0xbe, 0xe1, 0x84, 0xcc, 0xfe, 0x1a, 0xbd, 0x17, 0x61, 0x92, 0x11, 0xe1, 0x2d, + 0xc8, 0x6d, 0xd9, 0x34, 0x00, 0xee, 0x3c, 0x5a, 0xd8, 0x14, 0xfb, 0x66, 0x97, 0x13, 0x98, 0x0e, + 0xbd, 0x27, 0xf5, 0x8e, 0x5e, 0xdb, 0xdc, 0x66, 0x06, 0xbb, 0x7a, 0x15, 0x12, 0xd5, 0x5a, 0xfc, + 0x14, 0xd7, 0x7d, 0xb7, 0xb3, 0x06, 0xf5, 0x8d, 0x7c, 0xbe, 0x89, 0x1a, 0x48, 0x49, 0xd6, 0x40, + 0xea, 0x3a, 0x3a, 0x36, 0x52, 0x04, 0x00, 0x1c, 0x1b, 0x02, 0x2e, 0xa1, 0xc5, 0xe1, 0x32, 0xb1, + 0x70, 0x00, 0xf9, 0xd7, 0x64, 0x56, 0x0d, 0x5c, 0xf8, 0xf4, 0x44, 0x05, 0x38, 0x99, 0xac, 0x00, + 0x8f, 0xa1, 0xfd, 0xee, 0x5d, 0x67, 0x20, 0xe6, 0x44, 0xc5, 0xde, 0x3e, 0xb1, 0x28, 0x1f, 0x52, + 0x5c, 0x09, 0xee, 0xce, 0xab, 0x04, 0xa7, 0x9e, 0xbb, 0x12, 0xbc, 0x8d, 0x66, 0x98, 0xc3, 0x42, + 0x13, 0xe2, 0xff, 0xb4, 0x10, 0x54, 0xcb, 0x17, 0xb4, 0xe1, 0xb0, 0x90, 0x11, 0x9b, 0x7d, 0x97, + 0x24, 0x03, 0xb5, 0x81, 0xb8, 0x98, 0x28, 0x4b, 0x24, 0xef, 0x74, 0x4f, 0xaa, 0xae, 0xcd, 0x2a, + 0x2d, 0x4b, 0x99, 0xa5, 0xe5, 0x6a, 0xea, 0xdd, 0x40, 0xb3, 0x72, 0x87, 0x75, 0x68, 0xe1, 0xbb, + 0x6b, 0xa7, 0x62, 0x7f, 0x42, 0x06, 0x5c, 0xe0, 0x0d, 0x24, 0x7b, 0x1e, 0x93, 0xf7, 0xb9, 0x90, + 0x04, 0x2b, 0x5a, 0xd4, 0xe3, 0x6a, 0xb2, 0xc7, 0xd5, 0xee, 0xc8, 0x26, 0x78, 0xb5, 0xc4, 0xad, + 0xf8, 0xee, 0x27, 0x55, 0xc5, 0x98, 0x69, 0xf6, 0x05, 0xaa, 0x6b, 0xa9, 0xc3, 0xd6, 0x29, 0x0d, + 0xea, 0xd4, 0x17, 0x8f, 0xab, 0x30, 0xe2, 0xdf, 0xca, 0x7a, 0x33, 0x5b, 0x0a, 0x60, 0xf6, 0x10, + 0xb7, 0x56, 0x60, 0x7a, 0xd4, 0x37, 0xc5, 0xeb, 0x03, 0xd4, 0x8b, 0x89, 0x66, 0x45, 0x46, 0xd2, + 0x35, 0x97, 0x39, 0xab, 0x3a, 0x07, 0xfd, 0x9f, 0x27, 0xd5, 0x57, 0x9b, 0x2c, 0x6c, 0x75, 0x37, + 0xb5, 0x86, 0xdb, 0x81, 0x3e, 0x18, 0xfe, 0x59, 0x0e, 0xac, 0xb6, 0x1e, 0x6e, 0x7b, 0x34, 0x10, + 0x0c, 0xc6, 0xbe, 0xad, 0x81, 0x93, 0x39, 0x70, 0x16, 0x98, 0x6e, 0x8f, 0xfa, 0x3e, 0xb3, 0xa8, + 0x70, 0xe4, 0x92, 0x81, 0x58, 0x70, 0x0b, 0x56, 0xd4, 0x1e, 0x3a, 0x2d, 0x0b, 0xbf, 0x2c, 0xe8, + 0x92, 0x2e, 0x4e, 0xdc, 0xc9, 0x26, 0x50, 0x79, 0xee, 0x26, 0xf0, 0x91, 0x82, 0x96, 0x0b, 0x1e, + 0x1c, 0x47, 0xdb, 0xbd, 0x52, 0x0f, 0x19, 0x6c, 0xb5, 0x7c, 0x97, 0xcf, 0x92, 0x05, 0xef, 0xa8, + 0x2f, 0xe6, 0xc5, 0x75, 0x8e, 0xf7, 0x87, 0x9d, 0x88, 0x3f, 0x8a, 0x35, 0x9b, 0xb0, 0x4e, 0x51, + 0x27, 0xc2, 0x17, 0xd0, 0x5e, 0x8b, 0x7a, 0x6e, 0xc0, 0x42, 0xd7, 0x87, 0x0a, 0xb4, 0xfc, 0xf8, + 0xe1, 0xf2, 0x1c, 0xe0, 0x49, 0x66, 0xf0, 0x3e, 0xa9, 0xfa, 0xfd, 0x0c, 0xe7, 0x1b, 0x38, 0x1d, + 0xec, 0x47, 0xd0, 0x54, 0x83, 0x2f, 0x80, 0xed, 0x46, 0xf8, 0xdc, 0x19, 0x6e, 0xa6, 0x5f, 0x7e, + 0x52, 0x3d, 0x51, 0xd0, 0xe7, 0x02, 0x23, 0x92, 0xac, 0xfe, 0x4a, 0x41, 0xb3, 0xd7, 0x24, 0x2c, + 0x71, 0x7a, 0x52, 0x27, 0xa5, 0xb0, 0x4e, 0x7d, 0xb4, 0x93, 0xff, 0x37, 0xb4, 0xef, 0x8c, 0x32, + 0x5b, 0xe1, 0x4a, 0xf5, 0x85, 0x8d, 0x45, 0x7e, 0xa3, 0xa4, 0x52, 0x6f, 0x0a, 0x0e, 0x5c, 0xe3, + 0x65, 0x34, 0x2d, 0xe0, 0xcb, 0x37, 0x70, 0x64, 0xf8, 0x0d, 0x24, 0xaf, 0x40, 0x96, 0xff, 0x11, + 0xd7, 0x8b, 0x73, 0xf9, 0x2b, 0xa9, 0x71, 0xd6, 0x1b, 0xac, 0xc7, 0xa3, 0x6a, 0xf1, 0x12, 0xff, + 0xc7, 0x93, 0xe8, 0x70, 0x8e, 0x84, 0xfe, 0x44, 0xcc, 0x26, 0x41, 0x68, 0x92, 0x46, 0xfb, 0x39, + 0x82, 0x3c, 0x67, 0xbd, 0xda, 0x68, 0xf3, 0x3d, 0xbc, 0x8e, 0xf6, 0x35, 0x7d, 0xd2, 0xa0, 0x3c, + 0xf4, 0x32, 0xd7, 0x02, 0xbd, 0x17, 0x87, 0x04, 0x5d, 0x83, 0x89, 0x68, 0x24, 0xe7, 0xa7, 0x51, + 0xb2, 0xe0, 0x8c, 0x75, 0xc1, 0x87, 0xaf, 0xa3, 0x19, 0x9f, 0x76, 0x5c, 0xde, 0xf8, 0xd2, 0x90, + 0x40, 0x8b, 0x57, 0x0c, 0x0f, 0x02, 0xc6, 0xeb, 0x21, 0xc1, 0x15, 0x54, 0xb2, 0x68, 0xd3, 0x27, + 0x16, 0xb5, 0x44, 0x7d, 0x50, 0x32, 0xe2, 0x6f, 0xf5, 0x3a, 0xb8, 0x41, 0x9d, 0x3a, 0x16, 0x73, + 0x9a, 0xd7, 0xdc, 0xbb, 0x0e, 0xd7, 0xfd, 0xb6, 0x4d, 0x82, 0x16, 0x2d, 0x6e, 0xdd, 0x0e, 0x54, + 0x61, 0x79, 0x62, 0xc0, 0xc4, 0xeb, 0x68, 0x4f, 0x10, 0x2d, 0x81, 0x3f, 0x65, 0xf4, 0x7f, 0x59, + 0x22, 0xc0, 0xab, 0x24, 0x73, 0xdc, 0xf2, 0x7d, 0x93, 0x85, 0xad, 0x16, 0xb5, 0xad, 0x75, 0x4a, + 0x0d, 0xda, 0x70, 0x7d, 0xab, 0x38, 0xe2, 0x2d, 0xa8, 0x1c, 0xb2, 0x44, 0x00, 0xda, 0x35, 0xb4, + 0xc7, 0x8f, 0x96, 0x00, 0xed, 0xb1, 0x61, 0xb4, 0x43, 0xec, 0x12, 0x2a, 0x70, 0xd6, 0xfe, 0x5d, + 0x41, 0x53, 0xe2, 0x20, 0xfc, 0x6b, 0x05, 0xcd, 0x65, 0x15, 0x1a, 0x78, 0x79, 0x4c, 0x15, 0x9f, + 0x1c, 0xfd, 0x56, 0xb4, 0xa2, 0xe4, 0x91, 0x1a, 0xea, 0xf9, 0xef, 0x7d, 0xf4, 0xb7, 0x1f, 0x4d, + 0xea, 0x78, 0x59, 0x4f, 0x4e, 0xd4, 0x63, 0xfb, 0x40, 0x7d, 0xa2, 0xdf, 0x1f, 0xb0, 0xd8, 0x03, + 0xfc, 0x73, 0x39, 0x09, 0x48, 0x0e, 0x4e, 0xf1, 0xe9, 0x31, 0xc7, 0x27, 0xa6, 0xbf, 0x95, 0xe5, + 0x82, 0xd4, 0x80, 0x55, 0x13, 0x58, 0x4f, 0xe0, 0x57, 0xf2, 0xb0, 0x46, 0x43, 0x58, 0xfd, 0xbe, + 0x28, 0x70, 0x1f, 0xe0, 0x8f, 0xe5, 0xec, 0x39, 0x73, 0x96, 0x87, 0xcf, 0xe6, 0x9c, 0x3e, 0x6a, + 0x10, 0x59, 0x39, 0xb7, 0x33, 0x26, 0x40, 0x7e, 0x4b, 0x20, 0xdf, 0xc0, 0x37, 0x52, 0xc8, 0xe3, + 0x6e, 0xcb, 0x4c, 0x0c, 0x75, 0x92, 0xc6, 0xd6, 0xef, 0xa7, 0x27, 0x0b, 0x59, 0xaa, 0x0d, 0x4e, + 0xf1, 0xc6, 0xab, 0x96, 0x31, 0x82, 0x1c, 0xaf, 0x5a, 0xd6, 0xa0, 0xb0, 0x80, 0x6a, 0x09, 0xf4, + 0x69, 0xd5, 0xd2, 0xc3, 0xac, 0x07, 0xf8, 0x23, 0x99, 0x7c, 0x46, 0x0e, 0x00, 0xf1, 0x17, 0x73, + 0xd0, 0x16, 0x99, 0x42, 0x56, 0x2e, 0x3d, 0x1f, 0x33, 0xa8, 0x5c, 0x13, 0x2a, 0x9f, 0xc6, 0x27, + 0x53, 0x2a, 0x83, 0x0a, 0xa6, 0xc7, 0x45, 0xa4, 0x1e, 0xcc, 0x36, 0x9a, 0x19, 0x98, 0x9c, 0xe1, + 0x97, 0x73, 0x00, 0x24, 0xe6, 0x6d, 0x95, 0xe3, 0x63, 0xa8, 0x00, 0xcf, 0x61, 0x81, 0x67, 0x01, + 0xcf, 0xa7, 0xf0, 0xc0, 0x94, 0xed, 0x77, 0x0a, 0x5a, 0xc8, 0x69, 0xfc, 0xf1, 0x99, 0xc2, 0x33, + 0x02, 0x89, 0x69, 0x65, 0x07, 0x1c, 0x80, 0xef, 0x75, 0x81, 0xaf, 0x86, 0xcf, 0xe4, 0xbd, 0xdb, + 0xfe, 0xd0, 0x21, 0x65, 0xb5, 0x87, 0x0a, 0x34, 0xde, 0x59, 0xf3, 0x05, 0x9c, 0x37, 0xe0, 0x18, + 0x31, 0xb0, 0xa8, 0x9c, 0xdd, 0x11, 0xcf, 0x98, 0xc0, 0x93, 0x33, 0xd5, 0xc0, 0xbf, 0x4f, 0xff, + 0xb7, 0x52, 0x72, 0xee, 0x80, 0xcf, 0x8d, 0xb1, 0x61, 0xe6, 0xa4, 0xa3, 0x72, 0x7e, 0x87, 0x5c, + 0x45, 0xa3, 0x26, 0xb3, 0xf4, 0xfb, 0x71, 0xbb, 0xfd, 0x00, 0xff, 0x42, 0x81, 0xd9, 0x6f, 0x22, + 0x0a, 0xe3, 0x53, 0x45, 0x62, 0xb5, 0x84, 0x7a, 0xba, 0x18, 0x31, 0x20, 0x3c, 0x2b, 0x10, 0x2e, + 0xe3, 0x53, 0x23, 0xe3, 0x7a, 0xca, 0x35, 0xfe, 0xa8, 0xa0, 0x72, 0x5e, 0x67, 0x8e, 0x57, 0x8a, + 0x65, 0xc1, 0x81, 0x49, 0x40, 0xa5, 0xb6, 0x13, 0x16, 0x00, 0x7e, 0x51, 0x00, 0x3f, 0x87, 0x6b, + 0x63, 0x92, 0xa7, 0xa8, 0x18, 0x53, 0xf8, 0xff, 0xa4, 0xa4, 0x66, 0x4a, 0x83, 0x6d, 0x22, 0x1e, + 0x87, 0x26, 0x63, 0x32, 0x90, 0xeb, 0xda, 0xa3, 0xe6, 0x00, 0xea, 0x25, 0xa1, 0xc2, 0x05, 0x7c, + 0x2e, 0x4f, 0x85, 0xe4, 0x94, 0x20, 0xa5, 0xc4, 0x53, 0x05, 0x1d, 0x2f, 0xd4, 0x3a, 0xe3, 0xcb, + 0xf9, 0x11, 0xb7, 0x48, 0xb3, 0x5f, 0xb9, 0xf2, 0xdc, 0xfc, 0x45, 0x83, 0x50, 0x52, 0x51, 0xb3, + 0xdf, 0x99, 0x3f, 0x52, 0xd0, 0x5c, 0x56, 0x23, 0x54, 0xe4, 0x92, 0xd2, 0x9d, 0x77, 0x91, 0x4b, + 0x1a, 0xea, 0x97, 0xd5, 0x9b, 0x02, 0xfb, 0x75, 0xbc, 0xa6, 0x0f, 0xfd, 0xd9, 0xc3, 0x20, 0xfc, + 0x68, 0x26, 0x26, 0x9a, 0xab, 0x74, 0x9a, 0x8d, 0xbb, 0xd9, 0x07, 0xf8, 0xcf, 0x0a, 0x9a, 0xcf, + 0xec, 0xeb, 0xf0, 0x4e, 0xb0, 0x05, 0xe3, 0xaa, 0x86, 0x91, 0xad, 0xa3, 0xfa, 0x65, 0xa1, 0xd1, + 0x45, 0xfc, 0x7a, 0x61, 0x8d, 0xd2, 0xa9, 0xe1, 0x7d, 0x05, 0xcd, 0x67, 0xb6, 0x6c, 0x78, 0x5c, + 0x09, 0x9c, 0xea, 0x0e, 0x2b, 0x7a, 0x61, 0x7a, 0x00, 0x7f, 0x41, 0x80, 0x3f, 0x83, 0xb5, 0x3c, + 0x57, 0xb2, 0x81, 0x23, 0x05, 0xf9, 0x91, 0x4c, 0x0b, 0xd9, 0x8d, 0x50, 0x6e, 0x5a, 0x18, 0xd9, + 0x7e, 0xe5, 0xa6, 0x85, 0xd1, 0xdd, 0xd6, 0xa8, 0x1b, 0xf0, 0x22, 0x4e, 0xd3, 0x02, 0x56, 0x13, + 0x3a, 0xab, 0x94, 0x3a, 0x7f, 0x90, 0x75, 0xc5, 0x70, 0x97, 0x94, 0x5b, 0x57, 0xe4, 0xf6, 0x64, + 0xb9, 0x75, 0x45, 0x7e, 0x0b, 0x96, 0x1b, 0xbb, 0xc4, 0x9f, 0xf5, 0x44, 0x5c, 0xc2, 0x89, 0xa0, + 0xdb, 0x4a, 0xc2, 0x5f, 0xdd, 0xf8, 0xe0, 0xe9, 0x92, 0xf2, 0xe1, 0xd3, 0x25, 0xe5, 0xaf, 0x4f, + 0x97, 0x94, 0x77, 0x9f, 0x2d, 0x4d, 0x7c, 0xf8, 0x6c, 0x69, 0xe2, 0xe3, 0x67, 0x4b, 0x13, 0x6f, + 0xe9, 0x03, 0xe3, 0x1b, 0x62, 0xdb, 0xcc, 0xd9, 0x64, 0x61, 0x10, 0x9d, 0x71, 0x2f, 0x75, 0x94, + 0x98, 0xe5, 0x6c, 0x4e, 0x8b, 0x6e, 0xfb, 0xec, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0x38, 0xab, + 0x1c, 0xe5, 0x5b, 0x25, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -3556,6 +3569,16 @@ func (m *QueryParamsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + { + size, err := m.InfractionParameters.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 { size, err := m.Params.MarshalToSizedBuffer(dAtA[:i]) if err != nil { @@ -4008,12 +4031,12 @@ func (m *QueryConsumerGenesisTimeResponse) MarshalToSizedBuffer(dAtA []byte) (in _ = i var l int _ = l - n11, err11 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.GenesisTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.GenesisTime):]) - if err11 != nil { - return 0, err11 + n12, err12 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.GenesisTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.GenesisTime):]) + if err12 != nil { + return 0, err12 } - i -= n11 - i = encodeVarintQuery(dAtA, i, uint64(n11)) + i -= n12 + i = encodeVarintQuery(dAtA, i, uint64(n12)) i-- dAtA[i] = 0xa return len(dAtA) - i, nil @@ -4437,29 +4460,29 @@ func (m *QueryConsumerLivenessResponse) MarshalToSizedBuffer(dAtA []byte) (int, i-- dAtA[i] = 0x20 } - n17, err17 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.RemovalEta, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.RemovalEta):]) - if err17 != nil { - return 0, err17 - } - i -= n17 - i = encodeVarintQuery(dAtA, i, uint64(n17)) - i-- - dAtA[i] = 0x1a - n18, err18 := github_com_cosmos_gogoproto_types.StdDurationMarshalTo(m.GracePeriod, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdDuration(m.GracePeriod):]) + n18, err18 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.RemovalEta, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.RemovalEta):]) if err18 != nil { return 0, err18 } i -= n18 i = encodeVarintQuery(dAtA, i, uint64(n18)) i-- - dAtA[i] = 0x12 - n19, err19 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.LastAckTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.LastAckTime):]) + dAtA[i] = 0x1a + n19, err19 := github_com_cosmos_gogoproto_types.StdDurationMarshalTo(m.GracePeriod, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdDuration(m.GracePeriod):]) if err19 != nil { return 0, err19 } i -= n19 i = encodeVarintQuery(dAtA, i, uint64(n19)) i-- + dAtA[i] = 0x12 + n20, err20 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.LastAckTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.LastAckTime):]) + if err20 != nil { + return 0, err20 + } + i -= n20 + i = encodeVarintQuery(dAtA, i, uint64(n20)) + i-- dAtA[i] = 0xa return len(dAtA) - i, nil } @@ -4816,6 +4839,8 @@ func (m *QueryParamsResponse) Size() (n int) { _ = l l = m.Params.Size() n += 1 + l + sovQuery(uint64(l)) + l = m.InfractionParameters.Size() + n += 1 + l + sovQuery(uint64(l)) return n } @@ -6626,6 +6651,39 @@ func (m *QueryParamsResponse) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field InfractionParameters", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.InfractionParameters.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipQuery(dAtA[iNdEx:]) diff --git a/x/vaas/provider/types/tx.pb.go b/x/vaas/provider/types/tx.pb.go index 371cbbd5..5ab9e488 100644 --- a/x/vaas/provider/types/tx.pb.go +++ b/x/vaas/provider/types/tx.pb.go @@ -374,6 +374,119 @@ func (m *MsgUpdateParamsResponse) XXX_DiscardUnknown() { var xxx_messageInfo_MsgUpdateParamsResponse proto.InternalMessageInfo +// MsgUpdateInfractionParams is the Msg/UpdateInfractionParams request type. It +// replaces the provider's infraction parameters in full: the slash/jail policy +// for consumer double-signs and downtime, the downtime SLA window, the +// challenge window and the evidence max age. +// +// The infraction parameters are stored as their own state item rather than +// inside Params, so they get their own governance message: a fee or epoch +// change need not restate the whole slashing policy, and vice versa. Both +// handlers enforce the cross-parameter constraint the two sides share (see +// ValidateInfractionParamsAgainst), each against the stored other half. +// +// A proposal that widens downtime_evidence_max_age + +// downtime_challenge_window past the trusting period of a consumer client the +// provider has already adopted is rejected: challenges on that consumer would +// no longer verify, so its pending slashes would execute undefended. +// Narrowing is never blocked. +// +// A change to signed_blocks_window or min_signed_per_window redefines the +// downtime SLA consumers compute their bitmaps against. Consumers learn the +// new values from the next VSC packet and activate them at their next window +// boundary, while evidence already in flight echoes the old values; the +// provider keeps accepting those for downtime_evidence_max_age + +// downtime_challenge_window after the change (see AcceptableDowntimeParams). +type MsgUpdateInfractionParams struct { + // authority is the address of the governance account. + Authority string `protobuf:"bytes,1,opt,name=authority,proto3" json:"authority,omitempty"` + // infraction_parameters replaces the stored set in full. + InfractionParameters InfractionParameters `protobuf:"bytes,2,opt,name=infraction_parameters,json=infractionParameters,proto3" json:"infraction_parameters"` +} + +func (m *MsgUpdateInfractionParams) Reset() { *m = MsgUpdateInfractionParams{} } +func (m *MsgUpdateInfractionParams) String() string { return proto.CompactTextString(m) } +func (*MsgUpdateInfractionParams) ProtoMessage() {} +func (*MsgUpdateInfractionParams) Descriptor() ([]byte, []int) { + return fileDescriptor_a07778b1d094765c, []int{8} +} +func (m *MsgUpdateInfractionParams) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgUpdateInfractionParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgUpdateInfractionParams.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *MsgUpdateInfractionParams) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgUpdateInfractionParams.Merge(m, src) +} +func (m *MsgUpdateInfractionParams) XXX_Size() int { + return m.Size() +} +func (m *MsgUpdateInfractionParams) XXX_DiscardUnknown() { + xxx_messageInfo_MsgUpdateInfractionParams.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgUpdateInfractionParams proto.InternalMessageInfo + +func (m *MsgUpdateInfractionParams) GetAuthority() string { + if m != nil { + return m.Authority + } + return "" +} + +func (m *MsgUpdateInfractionParams) GetInfractionParameters() InfractionParameters { + if m != nil { + return m.InfractionParameters + } + return InfractionParameters{} +} + +type MsgUpdateInfractionParamsResponse struct { +} + +func (m *MsgUpdateInfractionParamsResponse) Reset() { *m = MsgUpdateInfractionParamsResponse{} } +func (m *MsgUpdateInfractionParamsResponse) String() string { return proto.CompactTextString(m) } +func (*MsgUpdateInfractionParamsResponse) ProtoMessage() {} +func (*MsgUpdateInfractionParamsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_a07778b1d094765c, []int{9} +} +func (m *MsgUpdateInfractionParamsResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgUpdateInfractionParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgUpdateInfractionParamsResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *MsgUpdateInfractionParamsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgUpdateInfractionParamsResponse.Merge(m, src) +} +func (m *MsgUpdateInfractionParamsResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgUpdateInfractionParamsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgUpdateInfractionParamsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgUpdateInfractionParamsResponse proto.InternalMessageInfo + // MsgRemoveConsumer defines the message used to remove (and stop) a consumer chain. // If it passes, all the consumer chain's state is eventually removed from the provider chain. // Only the governance authority can remove a consumer chain. @@ -388,7 +501,7 @@ func (m *MsgRemoveConsumer) Reset() { *m = MsgRemoveConsumer{} } func (m *MsgRemoveConsumer) String() string { return proto.CompactTextString(m) } func (*MsgRemoveConsumer) ProtoMessage() {} func (*MsgRemoveConsumer) Descriptor() ([]byte, []int) { - return fileDescriptor_a07778b1d094765c, []int{8} + return fileDescriptor_a07778b1d094765c, []int{10} } func (m *MsgRemoveConsumer) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -439,7 +552,7 @@ func (m *MsgRemoveConsumerResponse) Reset() { *m = MsgRemoveConsumerResp func (m *MsgRemoveConsumerResponse) String() string { return proto.CompactTextString(m) } func (*MsgRemoveConsumerResponse) ProtoMessage() {} func (*MsgRemoveConsumerResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_a07778b1d094765c, []int{9} + return fileDescriptor_a07778b1d094765c, []int{11} } func (m *MsgRemoveConsumerResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -483,7 +596,7 @@ func (m *MsgCreateConsumer) Reset() { *m = MsgCreateConsumer{} } func (m *MsgCreateConsumer) String() string { return proto.CompactTextString(m) } func (*MsgCreateConsumer) ProtoMessage() {} func (*MsgCreateConsumer) Descriptor() ([]byte, []int) { - return fileDescriptor_a07778b1d094765c, []int{10} + return fileDescriptor_a07778b1d094765c, []int{12} } func (m *MsgCreateConsumer) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -549,7 +662,7 @@ func (m *MsgCreateConsumerResponse) Reset() { *m = MsgCreateConsumerResp func (m *MsgCreateConsumerResponse) String() string { return proto.CompactTextString(m) } func (*MsgCreateConsumerResponse) ProtoMessage() {} func (*MsgCreateConsumerResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_a07778b1d094765c, []int{11} + return fileDescriptor_a07778b1d094765c, []int{13} } func (m *MsgCreateConsumerResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -607,7 +720,7 @@ func (m *MsgUpdateConsumer) Reset() { *m = MsgUpdateConsumer{} } func (m *MsgUpdateConsumer) String() string { return proto.CompactTextString(m) } func (*MsgUpdateConsumer) ProtoMessage() {} func (*MsgUpdateConsumer) Descriptor() ([]byte, []int) { - return fileDescriptor_a07778b1d094765c, []int{12} + return fileDescriptor_a07778b1d094765c, []int{14} } func (m *MsgUpdateConsumer) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -686,7 +799,7 @@ func (m *MsgUpdateConsumerResponse) Reset() { *m = MsgUpdateConsumerResp func (m *MsgUpdateConsumerResponse) String() string { return proto.CompactTextString(m) } func (*MsgUpdateConsumerResponse) ProtoMessage() {} func (*MsgUpdateConsumerResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_a07778b1d094765c, []int{13} + return fileDescriptor_a07778b1d094765c, []int{15} } func (m *MsgUpdateConsumerResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -737,7 +850,7 @@ func (m *MsgSetConsumerFeesPerBlock) Reset() { *m = MsgSetConsumerFeesPe func (m *MsgSetConsumerFeesPerBlock) String() string { return proto.CompactTextString(m) } func (*MsgSetConsumerFeesPerBlock) ProtoMessage() {} func (*MsgSetConsumerFeesPerBlock) Descriptor() ([]byte, []int) { - return fileDescriptor_a07778b1d094765c, []int{14} + return fileDescriptor_a07778b1d094765c, []int{16} } func (m *MsgSetConsumerFeesPerBlock) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -794,7 +907,7 @@ func (m *MsgSetConsumerFeesPerBlockResponse) Reset() { *m = MsgSetConsum func (m *MsgSetConsumerFeesPerBlockResponse) String() string { return proto.CompactTextString(m) } func (*MsgSetConsumerFeesPerBlockResponse) ProtoMessage() {} func (*MsgSetConsumerFeesPerBlockResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_a07778b1d094765c, []int{15} + return fileDescriptor_a07778b1d094765c, []int{17} } func (m *MsgSetConsumerFeesPerBlockResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -837,7 +950,7 @@ func (m *MsgFundConsumerFeePool) Reset() { *m = MsgFundConsumerFeePool{} func (m *MsgFundConsumerFeePool) String() string { return proto.CompactTextString(m) } func (*MsgFundConsumerFeePool) ProtoMessage() {} func (*MsgFundConsumerFeePool) Descriptor() ([]byte, []int) { - return fileDescriptor_a07778b1d094765c, []int{16} + return fileDescriptor_a07778b1d094765c, []int{18} } func (m *MsgFundConsumerFeePool) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -873,7 +986,7 @@ func (m *MsgFundConsumerFeePoolResponse) Reset() { *m = MsgFundConsumerF func (m *MsgFundConsumerFeePoolResponse) String() string { return proto.CompactTextString(m) } func (*MsgFundConsumerFeePoolResponse) ProtoMessage() {} func (*MsgFundConsumerFeePoolResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_a07778b1d094765c, []int{17} + return fileDescriptor_a07778b1d094765c, []int{19} } func (m *MsgFundConsumerFeePoolResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -922,7 +1035,7 @@ func (m *MsgWithdrawConsumerFeePool) Reset() { *m = MsgWithdrawConsumerF func (m *MsgWithdrawConsumerFeePool) String() string { return proto.CompactTextString(m) } func (*MsgWithdrawConsumerFeePool) ProtoMessage() {} func (*MsgWithdrawConsumerFeePool) Descriptor() ([]byte, []int) { - return fileDescriptor_a07778b1d094765c, []int{18} + return fileDescriptor_a07778b1d094765c, []int{20} } func (m *MsgWithdrawConsumerFeePool) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -961,7 +1074,7 @@ func (m *MsgWithdrawConsumerFeePoolResponse) Reset() { *m = MsgWithdrawC func (m *MsgWithdrawConsumerFeePoolResponse) String() string { return proto.CompactTextString(m) } func (*MsgWithdrawConsumerFeePoolResponse) ProtoMessage() {} func (*MsgWithdrawConsumerFeePoolResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_a07778b1d094765c, []int{19} + return fileDescriptor_a07778b1d094765c, []int{21} } func (m *MsgWithdrawConsumerFeePoolResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1012,7 +1125,7 @@ func (m *MsgSweepConsumerFeePool) Reset() { *m = MsgSweepConsumerFeePool func (m *MsgSweepConsumerFeePool) String() string { return proto.CompactTextString(m) } func (*MsgSweepConsumerFeePool) ProtoMessage() {} func (*MsgSweepConsumerFeePool) Descriptor() ([]byte, []int) { - return fileDescriptor_a07778b1d094765c, []int{20} + return fileDescriptor_a07778b1d094765c, []int{22} } func (m *MsgSweepConsumerFeePool) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1048,7 +1161,7 @@ func (m *MsgSweepConsumerFeePoolResponse) Reset() { *m = MsgSweepConsume func (m *MsgSweepConsumerFeePoolResponse) String() string { return proto.CompactTextString(m) } func (*MsgSweepConsumerFeePoolResponse) ProtoMessage() {} func (*MsgSweepConsumerFeePoolResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_a07778b1d094765c, []int{21} + return fileDescriptor_a07778b1d094765c, []int{23} } func (m *MsgSweepConsumerFeePoolResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1102,7 +1215,7 @@ func (m *MsgChallengeConsumerDowntime) Reset() { *m = MsgChallengeConsum func (m *MsgChallengeConsumerDowntime) String() string { return proto.CompactTextString(m) } func (*MsgChallengeConsumerDowntime) ProtoMessage() {} func (*MsgChallengeConsumerDowntime) Descriptor() ([]byte, []int) { - return fileDescriptor_a07778b1d094765c, []int{22} + return fileDescriptor_a07778b1d094765c, []int{24} } func (m *MsgChallengeConsumerDowntime) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1138,7 +1251,7 @@ func (m *MsgChallengeConsumerDowntimeResponse) Reset() { *m = MsgChallen func (m *MsgChallengeConsumerDowntimeResponse) String() string { return proto.CompactTextString(m) } func (*MsgChallengeConsumerDowntimeResponse) ProtoMessage() {} func (*MsgChallengeConsumerDowntimeResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_a07778b1d094765c, []int{23} + return fileDescriptor_a07778b1d094765c, []int{25} } func (m *MsgChallengeConsumerDowntimeResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1181,7 +1294,7 @@ func (m *MsgResumeConsumer) Reset() { *m = MsgResumeConsumer{} } func (m *MsgResumeConsumer) String() string { return proto.CompactTextString(m) } func (*MsgResumeConsumer) ProtoMessage() {} func (*MsgResumeConsumer) Descriptor() ([]byte, []int) { - return fileDescriptor_a07778b1d094765c, []int{24} + return fileDescriptor_a07778b1d094765c, []int{26} } func (m *MsgResumeConsumer) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1231,7 +1344,7 @@ func (m *MsgResumeConsumerResponse) Reset() { *m = MsgResumeConsumerResp func (m *MsgResumeConsumerResponse) String() string { return proto.CompactTextString(m) } func (*MsgResumeConsumerResponse) ProtoMessage() {} func (*MsgResumeConsumerResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_a07778b1d094765c, []int{25} + return fileDescriptor_a07778b1d094765c, []int{27} } func (m *MsgResumeConsumerResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1269,6 +1382,8 @@ func init() { proto.RegisterType((*MsgSubmitConsumerDoubleVotingResponse)(nil), "vaas.provider.v1.MsgSubmitConsumerDoubleVotingResponse") proto.RegisterType((*MsgUpdateParams)(nil), "vaas.provider.v1.MsgUpdateParams") proto.RegisterType((*MsgUpdateParamsResponse)(nil), "vaas.provider.v1.MsgUpdateParamsResponse") + proto.RegisterType((*MsgUpdateInfractionParams)(nil), "vaas.provider.v1.MsgUpdateInfractionParams") + proto.RegisterType((*MsgUpdateInfractionParamsResponse)(nil), "vaas.provider.v1.MsgUpdateInfractionParamsResponse") proto.RegisterType((*MsgRemoveConsumer)(nil), "vaas.provider.v1.MsgRemoveConsumer") proto.RegisterType((*MsgRemoveConsumerResponse)(nil), "vaas.provider.v1.MsgRemoveConsumerResponse") proto.RegisterType((*MsgCreateConsumer)(nil), "vaas.provider.v1.MsgCreateConsumer") @@ -1292,105 +1407,109 @@ func init() { func init() { proto.RegisterFile("vaas/provider/v1/tx.proto", fileDescriptor_a07778b1d094765c) } var fileDescriptor_a07778b1d094765c = []byte{ - // 1562 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x58, 0x4d, 0x6c, 0x1b, 0xc5, - 0x17, 0xcf, 0xe6, 0xab, 0xcd, 0x24, 0x4d, 0x9b, 0x6d, 0xda, 0xc4, 0xfe, 0xf7, 0x6f, 0xa7, 0xa6, - 0x4d, 0xd3, 0xd2, 0xee, 0x36, 0x01, 0x5a, 0x11, 0x55, 0x95, 0x9a, 0x84, 0xaa, 0x11, 0x8a, 0x88, - 0xb6, 0xa2, 0x48, 0x08, 0x61, 0x8d, 0x77, 0xa7, 0xeb, 0x51, 0x76, 0x67, 0xcc, 0xce, 0xd8, 0x6e, - 0x10, 0x48, 0x08, 0x24, 0x44, 0x6f, 0x70, 0xe4, 0xd6, 0x23, 0x42, 0x42, 0xea, 0xa1, 0x67, 0xce, - 0x3d, 0x96, 0x9e, 0x10, 0x87, 0x82, 0x52, 0x89, 0x72, 0xe2, 0xc0, 0x91, 0x13, 0x9a, 0xd9, 0xd9, - 0xf5, 0xda, 0xde, 0xb5, 0x9d, 0x42, 0x7b, 0x49, 0x3c, 0xf3, 0x7e, 0xef, 0xeb, 0xf7, 0xe6, 0xe3, - 0xcd, 0x82, 0x5c, 0x03, 0x42, 0x66, 0xd6, 0x02, 0xda, 0xc0, 0x0e, 0x0a, 0xcc, 0xc6, 0xb2, 0xc9, - 0xef, 0x18, 0xb5, 0x80, 0x72, 0xaa, 0x1f, 0x11, 0x22, 0x23, 0x12, 0x19, 0x8d, 0xe5, 0xfc, 0x0c, - 0xf4, 0x31, 0xa1, 0xa6, 0xfc, 0x1b, 0x82, 0xf2, 0x05, 0x9b, 0x32, 0x9f, 0x32, 0xb3, 0x02, 0x19, - 0x32, 0x1b, 0xcb, 0x15, 0xc4, 0xe1, 0xb2, 0x69, 0x53, 0x4c, 0x94, 0x7c, 0x4e, 0xc9, 0x7d, 0xe6, - 0x0a, 0xe3, 0x3e, 0x73, 0x95, 0x20, 0x17, 0x0a, 0xca, 0x72, 0x64, 0x86, 0x03, 0x25, 0x9a, 0x75, - 0xa9, 0x4b, 0xc3, 0x79, 0xf1, 0x4b, 0xcd, 0x9e, 0x70, 0x29, 0x75, 0x3d, 0x64, 0xc2, 0x1a, 0x36, - 0x21, 0x21, 0x94, 0x43, 0x8e, 0x29, 0x89, 0x74, 0x72, 0x4a, 0x2a, 0x47, 0x95, 0xfa, 0x6d, 0x13, - 0x92, 0xdd, 0x28, 0xc4, 0x4e, 0x91, 0x53, 0x0f, 0xa4, 0xae, 0x92, 0x17, 0x3b, 0xe5, 0x1c, 0xfb, - 0x88, 0x71, 0xe8, 0xd7, 0x22, 0x00, 0xae, 0xd8, 0xa6, 0x4d, 0x03, 0x64, 0xda, 0x1e, 0x46, 0x84, - 0x8b, 0x44, 0xc2, 0x5f, 0x0a, 0x60, 0x0a, 0x80, 0x87, 0xdd, 0x2a, 0x0f, 0xa7, 0x99, 0xc9, 0x11, - 0x71, 0x50, 0xe0, 0xe3, 0x10, 0xdc, 0x1a, 0x45, 0x16, 0x13, 0x72, 0xbe, 0x5b, 0x43, 0xcc, 0x44, - 0x82, 0x64, 0x62, 0xa3, 0x28, 0xd9, 0x2e, 0x80, 0xfc, 0x1b, 0xa9, 0x77, 0x15, 0x2d, 0xae, 0x92, - 0x04, 0x94, 0x7e, 0xd1, 0xc0, 0xec, 0x16, 0x73, 0xaf, 0x31, 0x86, 0x5d, 0xb2, 0x4e, 0x09, 0xab, - 0xfb, 0x28, 0x78, 0x1b, 0xed, 0xea, 0x45, 0x30, 0x69, 0xab, 0x61, 0x19, 0x3b, 0xf3, 0xda, 0x82, - 0xb6, 0x34, 0x6a, 0x81, 0x68, 0x6a, 0xd3, 0xd1, 0x2f, 0x83, 0x43, 0x91, 0xad, 0x32, 0x74, 0x9c, - 0x60, 0x7e, 0x78, 0x41, 0x5b, 0x9a, 0x58, 0xd3, 0xff, 0x7a, 0x52, 0x9c, 0xde, 0x85, 0xbe, 0xb7, - 0x5a, 0x12, 0xb3, 0x88, 0xb1, 0x92, 0x35, 0x15, 0x01, 0xaf, 0x39, 0x4e, 0xa0, 0x9f, 0x04, 0x53, - 0xb1, 0xe5, 0x1d, 0xb4, 0x3b, 0x3f, 0x22, 0xf4, 0xac, 0xd8, 0x9b, 0x70, 0x7e, 0x11, 0x8c, 0x8b, - 0x78, 0x50, 0x30, 0x3f, 0x2a, 0x8d, 0xce, 0x3f, 0x7e, 0x70, 0x61, 0x56, 0x55, 0xfe, 0x5a, 0x68, - 0xf5, 0x26, 0x0f, 0x30, 0x71, 0x2d, 0x85, 0x5b, 0x3d, 0xfa, 0xd5, 0xbd, 0xe2, 0xd0, 0x1f, 0xf7, - 0x8a, 0x43, 0x9f, 0x3f, 0xbb, 0x7f, 0x4e, 0x4d, 0x96, 0x0a, 0xe0, 0x44, 0x5a, 0x6e, 0x16, 0x62, - 0x35, 0x4a, 0x18, 0x2a, 0xed, 0x69, 0xe0, 0xff, 0x5b, 0xcc, 0xbd, 0x59, 0xaf, 0xf8, 0x98, 0x47, - 0x80, 0x2d, 0xcc, 0x2a, 0xa8, 0x0a, 0x1b, 0x98, 0xd6, 0x03, 0xfd, 0x12, 0x98, 0x60, 0x52, 0xca, - 0x51, 0x20, 0x39, 0xe8, 0x15, 0x4b, 0x0b, 0xaa, 0x6f, 0x83, 0x29, 0x3f, 0x61, 0x47, 0x72, 0x33, - 0xb9, 0x72, 0xde, 0xc0, 0x15, 0xdb, 0x48, 0x96, 0xdf, 0x48, 0x14, 0xbc, 0xb1, 0x6c, 0x24, 0x7d, - 0x5b, 0x6d, 0x16, 0x3a, 0xeb, 0x31, 0xd2, 0x59, 0x8f, 0xd5, 0xe3, 0x49, 0x06, 0x5a, 0xa1, 0x94, - 0xce, 0x80, 0xd3, 0x3d, 0x73, 0x8c, 0xd9, 0xf8, 0x69, 0x38, 0x85, 0x8d, 0x0d, 0x5a, 0xaf, 0x78, - 0xe8, 0x16, 0xe5, 0x98, 0xb8, 0xcf, 0xcd, 0x46, 0x19, 0xcc, 0x39, 0xf5, 0x9a, 0x87, 0x6d, 0xc8, - 0x51, 0xb9, 0x41, 0x39, 0x2a, 0x47, 0x8b, 0x58, 0x11, 0x73, 0x26, 0xc9, 0x43, 0xb8, 0x7e, 0x37, - 0x22, 0x85, 0x5b, 0x94, 0xa3, 0xb7, 0x14, 0xdc, 0x3a, 0xe6, 0xa4, 0x4d, 0xeb, 0x1f, 0x82, 0x39, - 0x4c, 0x6e, 0x07, 0xd0, 0x16, 0x9b, 0xb5, 0x5c, 0xf1, 0xa8, 0xbd, 0x53, 0xae, 0x22, 0xe8, 0xa0, - 0x40, 0x12, 0x35, 0xb9, 0xb2, 0xd8, 0x8f, 0xf9, 0x1b, 0x12, 0x6d, 0x1d, 0x6b, 0x99, 0x59, 0x13, - 0x56, 0xc2, 0xe9, 0x4e, 0xf2, 0x47, 0xff, 0x15, 0xf9, 0x49, 0x4a, 0x63, 0xf2, 0xbf, 0xd1, 0xc0, - 0xe1, 0x2d, 0xe6, 0xbe, 0x5b, 0x73, 0x20, 0x47, 0xdb, 0x30, 0x80, 0x3e, 0x13, 0x74, 0xc3, 0x3a, - 0xaf, 0xd2, 0x00, 0xf3, 0xdd, 0xfe, 0x74, 0xc7, 0x50, 0xfd, 0x12, 0x18, 0xaf, 0x49, 0x0b, 0x8a, - 0xdd, 0x79, 0xa3, 0xf3, 0x7c, 0x36, 0x42, 0x0f, 0x6b, 0xa3, 0x0f, 0x9f, 0x14, 0x87, 0x2c, 0x85, - 0x5e, 0x9d, 0x96, 0xc1, 0xc7, 0x76, 0x4a, 0x39, 0x30, 0xd7, 0x11, 0x52, 0x1c, 0xee, 0x27, 0x60, - 0x66, 0x8b, 0xb9, 0x16, 0xf2, 0x69, 0x03, 0x45, 0x79, 0xf5, 0x3f, 0x32, 0xda, 0x12, 0x1a, 0x1e, - 0x38, 0xa1, 0xae, 0xc0, 0xfe, 0x07, 0x72, 0x5d, 0xde, 0xe3, 0xd0, 0x7e, 0x18, 0x96, 0xb1, 0xad, - 0x07, 0x08, 0xf2, 0x56, 0x6c, 0xcf, 0xbb, 0x74, 0x73, 0xe0, 0xa0, 0x5d, 0x85, 0x98, 0x88, 0x84, - 0x64, 0xc4, 0xd6, 0x01, 0x39, 0xde, 0x74, 0xf4, 0x0d, 0x70, 0xd0, 0x47, 0x1c, 0x3a, 0x90, 0x43, - 0xb5, 0xca, 0x4a, 0xdd, 0x44, 0xc7, 0x3b, 0x4e, 0x21, 0x15, 0xe5, 0xb1, 0xa6, 0x4e, 0x41, 0x0e, - 0x13, 0xcc, 0x31, 0xf4, 0xf0, 0xc7, 0xf2, 0xae, 0x29, 0xcb, 0x6a, 0x20, 0x8e, 0x02, 0x26, 0x17, - 0xda, 0xe4, 0xca, 0x4a, 0xb6, 0xd9, 0xcd, 0x36, 0xd5, 0xed, 0x58, 0xd3, 0x9a, 0xc7, 0x19, 0x12, - 0x45, 0x66, 0x6b, 0x89, 0x5e, 0x91, 0x64, 0xb6, 0xd3, 0x15, 0x91, 0xd9, 0xb7, 0xa4, 0xa5, 0xbb, - 0x23, 0x92, 0xed, 0x70, 0x91, 0xc4, 0x6c, 0x1b, 0x60, 0x8c, 0x36, 0xc9, 0x00, 0x4c, 0x87, 0xb0, - 0x4e, 0x37, 0xc3, 0x5d, 0x2b, 0x67, 0x03, 0xcc, 0x10, 0xd4, 0x2c, 0x4b, 0x74, 0x59, 0xdd, 0x2b, - 0xe1, 0xc5, 0xd1, 0xc3, 0xf8, 0x61, 0x82, 0x9a, 0xef, 0x08, 0x0d, 0x35, 0xad, 0x5f, 0x4d, 0x54, - 0x6c, 0x74, 0xd0, 0x8a, 0x0d, 0x5a, 0xab, 0xb1, 0xff, 0xbe, 0x56, 0xfa, 0x02, 0x98, 0x12, 0x69, - 0xc7, 0x2b, 0x70, 0x5c, 0xae, 0x40, 0x40, 0x50, 0x73, 0x3d, 0x5c, 0x84, 0xab, 0x40, 0x54, 0x33, - 0x64, 0x51, 0x6d, 0x8b, 0xf6, 0x52, 0xb4, 0xb6, 0x85, 0x06, 0xf2, 0xe2, 0x28, 0x42, 0xf1, 0x39, - 0x74, 0x1d, 0x21, 0xb6, 0x8d, 0x02, 0x79, 0xce, 0x3d, 0xf7, 0x59, 0xd3, 0xb7, 0x72, 0x8b, 0x60, - 0x1c, 0xfa, 0xb4, 0x4e, 0xb8, 0x2a, 0xd7, 0xf4, 0xe3, 0x07, 0x17, 0x80, 0xb2, 0xba, 0x49, 0xb8, - 0xa5, 0xa4, 0x5d, 0x7b, 0xfc, 0x14, 0x28, 0x65, 0x87, 0x1b, 0x67, 0xf5, 0xa3, 0x06, 0x8e, 0x6f, - 0x31, 0xf7, 0x7a, 0x9d, 0x38, 0x09, 0xdc, 0x36, 0xa5, 0x5e, 0xa2, 0x87, 0xd0, 0x06, 0xeb, 0x21, - 0xfa, 0xe7, 0x72, 0xa5, 0x2d, 0x97, 0xc9, 0x95, 0x9c, 0xa1, 0xec, 0x89, 0x9e, 0xd6, 0x50, 0x3d, - 0xad, 0xb1, 0x4e, 0x31, 0x59, 0x9b, 0x10, 0xdb, 0xfc, 0xbb, 0x67, 0xf7, 0xcf, 0x69, 0x71, 0x86, - 0xa9, 0x2d, 0xca, 0x02, 0x28, 0xa4, 0xc7, 0x1f, 0xa7, 0xf8, 0x67, 0x58, 0xb8, 0xf7, 0x30, 0xaf, - 0x3a, 0x01, 0x6c, 0xbe, 0x84, 0x34, 0xab, 0x89, 0x34, 0x47, 0x7a, 0xa7, 0xf9, 0x86, 0x48, 0xf3, - 0xfb, 0x5f, 0x8b, 0x4b, 0x2e, 0xe6, 0xd5, 0x7a, 0xc5, 0xb0, 0xa9, 0xaf, 0x3a, 0x74, 0xf5, 0xef, - 0x02, 0x73, 0x76, 0x54, 0x47, 0x2a, 0x14, 0xd8, 0x00, 0x94, 0xdc, 0xd5, 0x64, 0xe9, 0x33, 0x12, - 0x8e, 0x8f, 0x26, 0x3b, 0x8e, 0x52, 0xeb, 0x17, 0xe5, 0xc5, 0xfd, 0x46, 0x19, 0x05, 0x58, 0xfa, - 0x56, 0x93, 0x77, 0xe0, 0xcd, 0x26, 0x42, 0xb5, 0x97, 0xc0, 0xfc, 0x71, 0x30, 0xee, 0x20, 0x42, - 0x7d, 0x26, 0x99, 0x9f, 0xb0, 0xd4, 0x28, 0x9d, 0xa7, 0x93, 0xa0, 0x98, 0x11, 0x5a, 0xbc, 0x76, - 0xfe, 0x1e, 0x96, 0x1d, 0xf0, 0x7a, 0x15, 0x7a, 0x1e, 0x22, 0x2e, 0x6a, 0xb5, 0x20, 0x4d, 0x22, - 0xde, 0x2e, 0x2f, 0x22, 0x87, 0xd3, 0x60, 0xba, 0x01, 0x3d, 0xec, 0x40, 0x4e, 0xd5, 0xc3, 0x40, - 0x6c, 0x96, 0x29, 0xeb, 0x50, 0x3c, 0x2b, 0x5f, 0x01, 0xa7, 0xc1, 0xb4, 0xed, 0x41, 0xec, 0x23, - 0xa7, 0x5c, 0x45, 0xa2, 0x2f, 0x93, 0x27, 0xf2, 0x88, 0x75, 0x48, 0xcd, 0xde, 0x90, 0x93, 0xfa, - 0x55, 0x30, 0xae, 0x1a, 0xb9, 0xb1, 0x7d, 0x35, 0x72, 0x4a, 0x4b, 0x7f, 0x13, 0x4c, 0x7a, 0x90, - 0xf1, 0xb2, 0x4d, 0x7d, 0x1f, 0x73, 0x79, 0x80, 0x8a, 0x86, 0xa8, 0xab, 0xdd, 0x5c, 0x97, 0x72, - 0x0b, 0x08, 0x70, 0xf8, 0x5b, 0x3f, 0x0b, 0x8e, 0xb4, 0x12, 0xa9, 0xd5, 0x2b, 0xe2, 0xad, 0x72, - 0x40, 0xa6, 0x72, 0x38, 0x9e, 0xdf, 0x96, 0xd3, 0xe9, 0xf5, 0x59, 0x04, 0xa7, 0x7a, 0x71, 0xdf, - 0xd5, 0x4b, 0x09, 0x69, 0xb2, 0x5f, 0x79, 0x21, 0xe7, 0x71, 0x66, 0x2f, 0x95, 0xf4, 0x1e, 0x85, - 0xb6, 0xf2, 0xfb, 0x24, 0x18, 0xd9, 0x62, 0xae, 0xbe, 0x03, 0x66, 0xba, 0x5f, 0x88, 0x8b, 0xdd, - 0x57, 0x5d, 0xda, 0x6b, 0x2b, 0x6f, 0x0c, 0x86, 0x8b, 0x37, 0xf6, 0x97, 0x1a, 0xc8, 0xf7, 0x78, - 0x92, 0x99, 0xa9, 0xe6, 0xb2, 0x15, 0xf2, 0x97, 0xf7, 0xa9, 0xd0, 0x23, 0x90, 0xb6, 0xd7, 0xd0, - 0x20, 0x81, 0x24, 0x15, 0x06, 0x0a, 0x24, 0xed, 0x71, 0xa0, 0x57, 0xc0, 0x74, 0x47, 0x3b, 0xfb, - 0x4a, 0xaa, 0xa9, 0x76, 0x50, 0xfe, 0xd5, 0x01, 0x40, 0x49, 0x1f, 0x1d, 0x4d, 0x5c, 0xba, 0x8f, - 0x76, 0x50, 0x86, 0x8f, 0xf4, 0x1e, 0x44, 0xf8, 0xe8, 0x78, 0x32, 0xa4, 0xfb, 0x68, 0x07, 0x65, - 0xf8, 0x48, 0x6f, 0xff, 0xf5, 0x0f, 0xc0, 0x54, 0xdb, 0x23, 0xea, 0x64, 0x8f, 0x00, 0x43, 0x48, - 0xfe, 0x6c, 0x5f, 0x48, 0x6c, 0xfd, 0x53, 0x30, 0x97, 0xd5, 0x41, 0x9d, 0x4f, 0xaf, 0x6e, 0x3a, - 0x3a, 0xff, 0xfa, 0x7e, 0xd0, 0xb1, 0xfb, 0x8f, 0xc0, 0xd1, 0xb4, 0x56, 0x67, 0x29, 0xd5, 0x58, - 0x0a, 0x32, 0x7f, 0x71, 0x50, 0x64, 0x32, 0xe3, 0xac, 0xd6, 0x23, 0x3d, 0xe3, 0x0c, 0x74, 0x46, - 0xc6, 0xfd, 0x6e, 0x79, 0x0e, 0x66, 0x53, 0x2f, 0xdf, 0xf4, 0x9a, 0xa5, 0x41, 0xf3, 0xcb, 0x03, - 0x43, 0x63, 0xaf, 0x5f, 0x68, 0x20, 0x97, 0x7d, 0x69, 0xa6, 0x1f, 0x68, 0x99, 0xf8, 0xfc, 0xa5, - 0xfd, 0xe1, 0xdb, 0xb7, 0x4b, 0xdb, 0xad, 0x90, 0xb5, 0x5d, 0x92, 0xa0, 0xcc, 0xed, 0x92, 0x76, - 0xc2, 0xe7, 0xc7, 0x3e, 0x13, 0x0d, 0xd9, 0xda, 0xe6, 0xc3, 0xbd, 0x82, 0xf6, 0x68, 0xaf, 0xa0, - 0xfd, 0xb6, 0x57, 0xd0, 0xbe, 0x7e, 0x5a, 0x18, 0x7a, 0xf4, 0xb4, 0x30, 0xf4, 0xf3, 0xd3, 0xc2, - 0xd0, 0xfb, 0x66, 0xa2, 0x67, 0x82, 0x9e, 0x87, 0x49, 0x05, 0x73, 0x66, 0xca, 0xcf, 0x8a, 0x77, - 0xcc, 0xf6, 0xaf, 0x8b, 0xf2, 0x26, 0xad, 0x8c, 0xcb, 0x0f, 0x8b, 0xaf, 0xfd, 0x13, 0x00, 0x00, - 0xff, 0xff, 0xf9, 0x72, 0xb5, 0x24, 0x30, 0x16, 0x00, 0x00, + // 1618 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x58, 0x4d, 0x6c, 0x14, 0x47, + 0x16, 0x76, 0xfb, 0x0f, 0x5c, 0x36, 0x06, 0x37, 0xc6, 0xf6, 0xcc, 0xb2, 0x33, 0xf6, 0x00, 0xc6, + 0xb0, 0x30, 0x8d, 0xcd, 0x2e, 0x68, 0x2d, 0x84, 0x84, 0xed, 0x45, 0x58, 0x2b, 0x6b, 0xad, 0x46, + 0x4b, 0xa4, 0x28, 0xca, 0xa8, 0xa6, 0xbb, 0xe8, 0x29, 0xb9, 0xbb, 0x6b, 0xd2, 0x55, 0x33, 0xc6, + 0x28, 0x91, 0xa2, 0x44, 0x8a, 0xc2, 0x2d, 0x39, 0xe6, 0xc6, 0x31, 0x8a, 0x14, 0x89, 0x03, 0xe7, + 0x1c, 0x23, 0x8e, 0x84, 0x53, 0x94, 0x03, 0x89, 0xcc, 0x81, 0x9c, 0x72, 0xc8, 0x31, 0xa7, 0xa8, + 0xaa, 0xab, 0x6b, 0xba, 0x67, 0xba, 0x67, 0xc6, 0x10, 0xb8, 0xd8, 0x53, 0xef, 0x7d, 0xf5, 0x7e, + 0xbe, 0x57, 0x3f, 0xaf, 0x1a, 0xe4, 0x9a, 0x10, 0x52, 0xa3, 0x1e, 0x90, 0x26, 0xb6, 0x51, 0x60, + 0x34, 0x97, 0x0d, 0x76, 0xaf, 0x5c, 0x0f, 0x08, 0x23, 0xfa, 0x31, 0xae, 0x2a, 0x47, 0xaa, 0x72, + 0x73, 0x39, 0x3f, 0x05, 0x3d, 0xec, 0x13, 0x43, 0xfc, 0x0d, 0x41, 0xf9, 0x82, 0x45, 0xa8, 0x47, + 0xa8, 0x51, 0x85, 0x14, 0x19, 0xcd, 0xe5, 0x2a, 0x62, 0x70, 0xd9, 0xb0, 0x08, 0xf6, 0xa5, 0x7e, + 0x56, 0xea, 0x3d, 0xea, 0x70, 0xe3, 0x1e, 0x75, 0xa4, 0x22, 0x17, 0x2a, 0x2a, 0x62, 0x64, 0x84, + 0x03, 0xa9, 0x9a, 0x76, 0x88, 0x43, 0x42, 0x39, 0xff, 0x25, 0xa5, 0x27, 0x1d, 0x42, 0x1c, 0x17, + 0x19, 0xb0, 0x8e, 0x0d, 0xe8, 0xfb, 0x84, 0x41, 0x86, 0x89, 0x1f, 0xcd, 0xc9, 0x49, 0xad, 0x18, + 0x55, 0x1b, 0x77, 0x0d, 0xe8, 0xef, 0x45, 0x21, 0xb6, 0xab, 0xec, 0x46, 0x20, 0xe6, 0x4a, 0x7d, + 0xb1, 0x5d, 0xcf, 0xb0, 0x87, 0x28, 0x83, 0x5e, 0x3d, 0x02, 0xe0, 0xaa, 0x65, 0x58, 0x24, 0x40, + 0x86, 0xe5, 0x62, 0xe4, 0x33, 0x9e, 0x48, 0xf8, 0x4b, 0x02, 0x0c, 0x0e, 0x70, 0xb1, 0x53, 0x63, + 0xa1, 0x98, 0x1a, 0x0c, 0xf9, 0x36, 0x0a, 0x3c, 0x1c, 0x82, 0x5b, 0xa3, 0xc8, 0x62, 0x4c, 0xcf, + 0xf6, 0xea, 0x88, 0x1a, 0x88, 0x93, 0xec, 0x5b, 0x28, 0x4a, 0xb6, 0x03, 0x20, 0xfe, 0x46, 0xd3, + 0x3b, 0x8a, 0xa6, 0xaa, 0x24, 0x00, 0xa5, 0x9f, 0x34, 0x30, 0xbd, 0x45, 0x9d, 0x1b, 0x94, 0x62, + 0xc7, 0x5f, 0x27, 0x3e, 0x6d, 0x78, 0x28, 0xf8, 0x2f, 0xda, 0xd3, 0x8b, 0x60, 0xdc, 0x92, 0xc3, + 0x0a, 0xb6, 0xe7, 0xb4, 0x79, 0x6d, 0x69, 0xd8, 0x04, 0x91, 0x68, 0xd3, 0xd6, 0xaf, 0x82, 0x23, + 0x91, 0xad, 0x0a, 0xb4, 0xed, 0x60, 0x6e, 0x70, 0x5e, 0x5b, 0x1a, 0x5b, 0xd3, 0x7f, 0x7f, 0x5e, + 0x9c, 0xdc, 0x83, 0x9e, 0xbb, 0x5a, 0xe2, 0x52, 0x44, 0x69, 0xc9, 0x9c, 0x88, 0x80, 0x37, 0x6c, + 0x3b, 0xd0, 0x17, 0xc0, 0x84, 0xb2, 0xbc, 0x83, 0xf6, 0xe6, 0x86, 0xf8, 0x3c, 0x53, 0x79, 0xe3, + 0xce, 0x2f, 0x81, 0x51, 0x1e, 0x0f, 0x0a, 0xe6, 0x86, 0x85, 0xd1, 0xb9, 0x67, 0x8f, 0x2f, 0x4e, + 0xcb, 0xca, 0xdf, 0x08, 0xad, 0xde, 0x66, 0x01, 0xf6, 0x1d, 0x53, 0xe2, 0x56, 0x8f, 0x7f, 0xfe, + 0xb0, 0x38, 0xf0, 0xeb, 0xc3, 0xe2, 0xc0, 0x27, 0x2f, 0x1f, 0x9d, 0x97, 0xc2, 0x52, 0x01, 0x9c, + 0x4c, 0xcb, 0xcd, 0x44, 0xb4, 0x4e, 0x7c, 0x8a, 0x4a, 0xfb, 0x1a, 0xf8, 0xfb, 0x16, 0x75, 0x6e, + 0x37, 0xaa, 0x1e, 0x66, 0x11, 0x60, 0x0b, 0xd3, 0x2a, 0xaa, 0xc1, 0x26, 0x26, 0x8d, 0x40, 0xbf, + 0x02, 0xc6, 0xa8, 0xd0, 0x32, 0x14, 0x08, 0x0e, 0xba, 0xc5, 0xd2, 0x82, 0xea, 0xdb, 0x60, 0xc2, + 0x8b, 0xd9, 0x11, 0xdc, 0x8c, 0xaf, 0x5c, 0x28, 0xe3, 0xaa, 0x55, 0x8e, 0x97, 0xbf, 0x1c, 0x2b, + 0x78, 0x73, 0xb9, 0x1c, 0xf7, 0x6d, 0x26, 0x2c, 0xb4, 0xd7, 0x63, 0xa8, 0xbd, 0x1e, 0xab, 0x33, + 0x71, 0x06, 0x5a, 0xa1, 0x94, 0xce, 0x82, 0x33, 0x5d, 0x73, 0x54, 0x6c, 0xfc, 0x30, 0x98, 0xc2, + 0xc6, 0x06, 0x69, 0x54, 0x5d, 0x74, 0x87, 0x30, 0xec, 0x3b, 0xaf, 0xcc, 0x46, 0x05, 0xcc, 0xda, + 0x8d, 0xba, 0x8b, 0x2d, 0xc8, 0x50, 0xa5, 0x49, 0x18, 0xaa, 0x44, 0x8b, 0x58, 0x12, 0x73, 0x36, + 0xce, 0x43, 0xb8, 0x7e, 0x37, 0xa2, 0x09, 0x77, 0x08, 0x43, 0xff, 0x91, 0x70, 0xf3, 0x84, 0x9d, + 0x26, 0xd6, 0xdf, 0x07, 0xb3, 0xd8, 0xbf, 0x1b, 0x40, 0x8b, 0x6f, 0xd6, 0x4a, 0xd5, 0x25, 0xd6, + 0x4e, 0xa5, 0x86, 0xa0, 0x8d, 0x02, 0x41, 0xd4, 0xf8, 0xca, 0x62, 0x2f, 0xe6, 0x6f, 0x09, 0xb4, + 0x79, 0xa2, 0x65, 0x66, 0x8d, 0x5b, 0x09, 0xc5, 0xed, 0xe4, 0x0f, 0xbf, 0x16, 0xf9, 0x71, 0x4a, + 0x15, 0xf9, 0x5f, 0x6a, 0xe0, 0xe8, 0x16, 0x75, 0xfe, 0x5f, 0xb7, 0x21, 0x43, 0xdb, 0x30, 0x80, + 0x1e, 0xe5, 0x74, 0xc3, 0x06, 0xab, 0x91, 0x00, 0xb3, 0xbd, 0xde, 0x74, 0x2b, 0xa8, 0x7e, 0x05, + 0x8c, 0xd6, 0x85, 0x05, 0xc9, 0xee, 0x5c, 0xb9, 0xfd, 0x7c, 0x2e, 0x87, 0x1e, 0xd6, 0x86, 0x9f, + 0x3c, 0x2f, 0x0e, 0x98, 0x12, 0xbd, 0x3a, 0x29, 0x82, 0x57, 0x76, 0x4a, 0x39, 0x30, 0xdb, 0x16, + 0x92, 0x0a, 0xf7, 0x7b, 0x0d, 0xe4, 0x94, 0x6e, 0x53, 0x71, 0xf6, 0x9a, 0x81, 0x43, 0x10, 0xe3, + 0xbf, 0x22, 0xa2, 0x42, 0x0c, 0x05, 0x51, 0x1e, 0x8b, 0x9d, 0x79, 0xb4, 0xb9, 0x16, 0x68, 0x99, + 0xd5, 0x34, 0x4e, 0xd1, 0x75, 0xe4, 0x78, 0x0a, 0x2c, 0x64, 0xe6, 0xa1, 0xb2, 0xfd, 0x10, 0x4c, + 0x6d, 0x51, 0xc7, 0x44, 0x1e, 0x69, 0xa2, 0xa8, 0x8a, 0xbd, 0x0f, 0xc8, 0x04, 0x0b, 0x83, 0x7d, + 0xb3, 0xd0, 0x11, 0xe2, 0xdf, 0x04, 0xd5, 0x49, 0xef, 0x2a, 0xb4, 0x6f, 0x07, 0x45, 0x6c, 0xeb, + 0x01, 0x82, 0xac, 0x15, 0xdb, 0xab, 0x6e, 0xd4, 0x1c, 0x38, 0x6c, 0xd5, 0x20, 0xf6, 0x79, 0x42, + 0x22, 0x62, 0xf3, 0x90, 0x18, 0x6f, 0xda, 0xfa, 0x06, 0x38, 0xec, 0x21, 0x06, 0x6d, 0xc8, 0xa0, + 0xdc, 0x53, 0xa5, 0xce, 0x72, 0xa8, 0xf3, 0x45, 0x22, 0x65, 0x29, 0xd4, 0x4c, 0x9d, 0x80, 0x1c, + 0xf6, 0x31, 0xc3, 0xd0, 0xc5, 0xf7, 0x61, 0x7b, 0x95, 0x87, 0x85, 0xd9, 0x95, 0x6c, 0xb3, 0x9b, + 0x89, 0xa9, 0xad, 0xaa, 0x9a, 0x73, 0x38, 0x43, 0x23, 0xc9, 0x6c, 0x6d, 0xc8, 0x6b, 0x82, 0xcc, + 0x24, 0x5d, 0x11, 0x99, 0x3d, 0x4b, 0x5a, 0x7a, 0x30, 0x24, 0xd8, 0x0e, 0x97, 0x8b, 0x62, 0xbb, + 0x0c, 0x46, 0xc8, 0xae, 0xdf, 0x07, 0xd3, 0x21, 0xac, 0xdd, 0xcd, 0x60, 0xc7, 0xca, 0xd9, 0x00, + 0x53, 0x3e, 0xda, 0xad, 0x08, 0x74, 0x45, 0xde, 0xa2, 0xe1, 0x35, 0xd9, 0xc5, 0xf8, 0x51, 0x1f, + 0xed, 0xfe, 0x8f, 0xcf, 0x90, 0x62, 0xfd, 0x7a, 0xac, 0x62, 0xc3, 0xfd, 0x56, 0xac, 0xdf, 0x5a, + 0x8d, 0xfc, 0xf5, 0xb5, 0xd2, 0xe7, 0xc1, 0x04, 0x4f, 0x5b, 0xad, 0xc0, 0x51, 0xb1, 0x02, 0x81, + 0x8f, 0x76, 0xd7, 0xc3, 0x45, 0xb8, 0x0a, 0x78, 0x35, 0x43, 0x16, 0xe5, 0xb6, 0x48, 0x96, 0xa2, + 0xb5, 0x2d, 0x34, 0x90, 0xe7, 0x07, 0x2f, 0x52, 0xa7, 0xee, 0x4d, 0x84, 0xe8, 0x36, 0x0a, 0xc4, + 0xa9, 0xfe, 0xca, 0x07, 0x54, 0xcf, 0xca, 0x2d, 0x82, 0x51, 0xe8, 0x91, 0x86, 0xcf, 0x64, 0xb9, + 0x26, 0x9f, 0x3d, 0xbe, 0x08, 0xa4, 0xd5, 0x4d, 0x9f, 0x99, 0x52, 0xdb, 0xb1, 0xc7, 0x4f, 0x83, + 0x52, 0x76, 0xb8, 0x2a, 0xab, 0xef, 0x34, 0x30, 0xb3, 0x45, 0x9d, 0x9b, 0x0d, 0xdf, 0x8e, 0xe1, + 0xb6, 0x09, 0x71, 0x63, 0x1d, 0x93, 0xd6, 0x5f, 0xc7, 0xd4, 0x3b, 0x97, 0x6b, 0x89, 0x5c, 0xc6, + 0x57, 0x72, 0x65, 0x69, 0x8f, 0x77, 0xf0, 0x65, 0xd9, 0xc1, 0x97, 0xd7, 0x09, 0xf6, 0xd7, 0xc6, + 0xf8, 0x36, 0xff, 0xfa, 0xe5, 0xa3, 0xf3, 0x9a, 0xca, 0x30, 0xb5, 0x21, 0x9b, 0x07, 0x85, 0xf4, + 0xf8, 0x55, 0x8a, 0xbf, 0x85, 0x85, 0x7b, 0x07, 0xb3, 0x9a, 0x1d, 0xc0, 0xdd, 0xb7, 0x90, 0x66, + 0x2d, 0x96, 0xe6, 0x50, 0xf7, 0x34, 0xff, 0xc5, 0xd3, 0xfc, 0xe6, 0xe7, 0xe2, 0x92, 0x83, 0x59, + 0xad, 0x51, 0x2d, 0x5b, 0xc4, 0x93, 0xef, 0x11, 0xf9, 0xef, 0x22, 0xb5, 0x77, 0x64, 0xff, 0xcd, + 0x27, 0xd0, 0x3e, 0x28, 0x79, 0xa0, 0x89, 0xd2, 0x67, 0x24, 0xac, 0x8e, 0x26, 0x4b, 0x45, 0xa9, + 0xf5, 0x8a, 0xf2, 0xd2, 0x41, 0xa3, 0x8c, 0x02, 0x2c, 0x7d, 0xa5, 0x89, 0x1b, 0xff, 0xf6, 0x2e, + 0x42, 0xf5, 0xb7, 0xc0, 0xfc, 0x0c, 0x18, 0xb5, 0x91, 0x4f, 0x3c, 0x2a, 0x98, 0x1f, 0x33, 0xe5, + 0x28, 0x9d, 0xa7, 0x05, 0x50, 0xcc, 0x08, 0x4d, 0xad, 0x9d, 0x3f, 0x06, 0x45, 0xbf, 0xbf, 0x5e, + 0x83, 0xae, 0x8b, 0x7c, 0x07, 0xb5, 0x1a, 0xae, 0x5d, 0x9f, 0xbf, 0xd4, 0xde, 0x44, 0x0e, 0x67, + 0xc0, 0x64, 0x13, 0xba, 0xd8, 0x86, 0x8c, 0xc8, 0x67, 0x10, 0xdf, 0x2c, 0x13, 0xe6, 0x11, 0x25, + 0x15, 0x6f, 0x9e, 0x33, 0x60, 0xd2, 0x72, 0x21, 0xf6, 0x90, 0x5d, 0xa9, 0x21, 0xde, 0x85, 0x8a, + 0x13, 0x79, 0xc8, 0x3c, 0x22, 0xa5, 0xb7, 0x84, 0x50, 0xbf, 0x0e, 0x46, 0x65, 0xdb, 0x3a, 0x72, + 0xa0, 0xb6, 0x55, 0xce, 0xd2, 0xff, 0x0d, 0xc6, 0x5d, 0x48, 0x59, 0xc5, 0x22, 0x9e, 0x87, 0x99, + 0x38, 0x40, 0x79, 0xfb, 0xd7, 0xd1, 0x5c, 0xaf, 0x0b, 0xbd, 0x09, 0x38, 0x38, 0xfc, 0xad, 0x9f, + 0x03, 0xc7, 0x5a, 0x89, 0xd4, 0x1b, 0x55, 0xfe, 0x32, 0x3b, 0x24, 0x52, 0x39, 0xaa, 0xe4, 0xdb, + 0x42, 0x9c, 0x5e, 0x9f, 0x45, 0x70, 0xba, 0x1b, 0xf7, 0x1d, 0xbd, 0x14, 0xd7, 0xc6, 0xfb, 0x95, + 0x37, 0x72, 0x1e, 0x67, 0xf6, 0x52, 0x71, 0xef, 0x51, 0x68, 0x2b, 0xfb, 0x13, 0x60, 0x68, 0x8b, + 0x3a, 0xfa, 0x0e, 0x98, 0xea, 0x7c, 0x0f, 0xa7, 0x34, 0x9f, 0x69, 0x6f, 0xcb, 0x7c, 0xb9, 0x3f, + 0x9c, 0xda, 0xd8, 0x9f, 0x69, 0x20, 0xdf, 0xe5, 0x01, 0x6a, 0xa4, 0x9a, 0xcb, 0x9e, 0x90, 0xbf, + 0x7a, 0xc0, 0x09, 0x5d, 0x02, 0x49, 0xbc, 0xfd, 0xfa, 0x09, 0x24, 0x3e, 0xa1, 0xaf, 0x40, 0xd2, + 0x9e, 0x42, 0x7a, 0x15, 0x4c, 0xb6, 0xb5, 0xb3, 0xa7, 0x52, 0x4d, 0x25, 0x41, 0xf9, 0x7f, 0xf4, + 0x01, 0x8a, 0xfb, 0x68, 0x6b, 0xe2, 0xd2, 0x7d, 0x24, 0x41, 0x19, 0x3e, 0xd2, 0x7b, 0x10, 0xee, + 0xa3, 0xed, 0xc9, 0x90, 0xee, 0x23, 0x09, 0xca, 0xf0, 0x91, 0xde, 0xfe, 0xeb, 0xef, 0x81, 0x89, + 0xc4, 0x93, 0x71, 0xa1, 0x4b, 0x80, 0x21, 0x24, 0x7f, 0xae, 0x27, 0x44, 0x59, 0xbf, 0x0f, 0x66, + 0x32, 0x5e, 0x78, 0xdd, 0x88, 0x68, 0x07, 0xe7, 0x2f, 0x1f, 0x00, 0xac, 0x7c, 0x7f, 0x04, 0x66, + 0xb3, 0xba, 0xb7, 0x0b, 0xe9, 0x2b, 0x2b, 0x1d, 0x9d, 0xff, 0xe7, 0x41, 0xd0, 0xca, 0xfd, 0x07, + 0xe0, 0x78, 0x5a, 0x9b, 0xb5, 0x94, 0x6a, 0x2c, 0x05, 0x99, 0xbf, 0xd4, 0x2f, 0x32, 0x9e, 0x71, + 0x56, 0xdb, 0x93, 0x9e, 0x71, 0x06, 0x3a, 0x23, 0xe3, 0x5e, 0x1d, 0x06, 0x03, 0xd3, 0xa9, 0x17, + 0x7f, 0xfa, 0x7a, 0x49, 0x83, 0xe6, 0x97, 0xfb, 0x86, 0x2a, 0xaf, 0x9f, 0x6a, 0x20, 0x97, 0x7d, + 0x61, 0xa7, 0x1f, 0xa6, 0x99, 0xf8, 0xfc, 0x95, 0x83, 0xe1, 0x93, 0x5b, 0x35, 0x71, 0x23, 0x65, + 0x6d, 0xd5, 0x38, 0x28, 0x73, 0xab, 0xa6, 0xdd, 0x2e, 0xf9, 0x91, 0x8f, 0x79, 0x33, 0xb8, 0xb6, + 0xf9, 0x64, 0xbf, 0xa0, 0x3d, 0xdd, 0x2f, 0x68, 0xbf, 0xec, 0x17, 0xb4, 0x2f, 0x5e, 0x14, 0x06, + 0x9e, 0xbe, 0x28, 0x0c, 0xfc, 0xf8, 0xa2, 0x30, 0xf0, 0xae, 0x11, 0xeb, 0xd7, 0xa0, 0xeb, 0x62, + 0xbf, 0x8a, 0x19, 0x35, 0xc4, 0x07, 0xdc, 0x7b, 0x46, 0xf2, 0x3b, 0xae, 0xb8, 0xc5, 0xab, 0xa3, + 0xe2, 0x13, 0xee, 0xe5, 0x3f, 0x03, 0x00, 0x00, 0xff, 0xff, 0xb9, 0x92, 0xec, 0x74, 0x9a, 0x17, + 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -1412,6 +1531,7 @@ type MsgClient interface { UpdateConsumer(ctx context.Context, in *MsgUpdateConsumer, opts ...grpc.CallOption) (*MsgUpdateConsumerResponse, error) RemoveConsumer(ctx context.Context, in *MsgRemoveConsumer, opts ...grpc.CallOption) (*MsgRemoveConsumerResponse, error) UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error) + UpdateInfractionParams(ctx context.Context, in *MsgUpdateInfractionParams, opts ...grpc.CallOption) (*MsgUpdateInfractionParamsResponse, error) SetConsumerFeesPerBlock(ctx context.Context, in *MsgSetConsumerFeesPerBlock, opts ...grpc.CallOption) (*MsgSetConsumerFeesPerBlockResponse, error) FundConsumerFeePool(ctx context.Context, in *MsgFundConsumerFeePool, opts ...grpc.CallOption) (*MsgFundConsumerFeePoolResponse, error) WithdrawConsumerFeePool(ctx context.Context, in *MsgWithdrawConsumerFeePool, opts ...grpc.CallOption) (*MsgWithdrawConsumerFeePoolResponse, error) @@ -1491,6 +1611,15 @@ func (c *msgClient) UpdateParams(ctx context.Context, in *MsgUpdateParams, opts return out, nil } +func (c *msgClient) UpdateInfractionParams(ctx context.Context, in *MsgUpdateInfractionParams, opts ...grpc.CallOption) (*MsgUpdateInfractionParamsResponse, error) { + out := new(MsgUpdateInfractionParamsResponse) + err := c.cc.Invoke(ctx, "/vaas.provider.v1.Msg/UpdateInfractionParams", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *msgClient) SetConsumerFeesPerBlock(ctx context.Context, in *MsgSetConsumerFeesPerBlock, opts ...grpc.CallOption) (*MsgSetConsumerFeesPerBlockResponse, error) { out := new(MsgSetConsumerFeesPerBlockResponse) err := c.cc.Invoke(ctx, "/vaas.provider.v1.Msg/SetConsumerFeesPerBlock", in, out, opts...) @@ -1554,6 +1683,7 @@ type MsgServer interface { UpdateConsumer(context.Context, *MsgUpdateConsumer) (*MsgUpdateConsumerResponse, error) RemoveConsumer(context.Context, *MsgRemoveConsumer) (*MsgRemoveConsumerResponse, error) UpdateParams(context.Context, *MsgUpdateParams) (*MsgUpdateParamsResponse, error) + UpdateInfractionParams(context.Context, *MsgUpdateInfractionParams) (*MsgUpdateInfractionParamsResponse, error) SetConsumerFeesPerBlock(context.Context, *MsgSetConsumerFeesPerBlock) (*MsgSetConsumerFeesPerBlockResponse, error) FundConsumerFeePool(context.Context, *MsgFundConsumerFeePool) (*MsgFundConsumerFeePoolResponse, error) WithdrawConsumerFeePool(context.Context, *MsgWithdrawConsumerFeePool) (*MsgWithdrawConsumerFeePoolResponse, error) @@ -1587,6 +1717,9 @@ func (*UnimplementedMsgServer) RemoveConsumer(ctx context.Context, req *MsgRemov func (*UnimplementedMsgServer) UpdateParams(ctx context.Context, req *MsgUpdateParams) (*MsgUpdateParamsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method UpdateParams not implemented") } +func (*UnimplementedMsgServer) UpdateInfractionParams(ctx context.Context, req *MsgUpdateInfractionParams) (*MsgUpdateInfractionParamsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method UpdateInfractionParams not implemented") +} func (*UnimplementedMsgServer) SetConsumerFeesPerBlock(ctx context.Context, req *MsgSetConsumerFeesPerBlock) (*MsgSetConsumerFeesPerBlockResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method SetConsumerFeesPerBlock not implemented") } @@ -1736,6 +1869,24 @@ func _Msg_UpdateParams_Handler(srv interface{}, ctx context.Context, dec func(in return interceptor(ctx, in, info, handler) } +func _Msg_UpdateInfractionParams_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgUpdateInfractionParams) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).UpdateInfractionParams(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vaas.provider.v1.Msg/UpdateInfractionParams", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).UpdateInfractionParams(ctx, req.(*MsgUpdateInfractionParams)) + } + return interceptor(ctx, in, info, handler) +} + func _Msg_SetConsumerFeesPerBlock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(MsgSetConsumerFeesPerBlock) if err := dec(in); err != nil { @@ -1876,6 +2027,10 @@ var _Msg_serviceDesc = grpc.ServiceDesc{ MethodName: "UpdateParams", Handler: _Msg_UpdateParams_Handler, }, + { + MethodName: "UpdateInfractionParams", + Handler: _Msg_UpdateInfractionParams_Handler, + }, { MethodName: "SetConsumerFeesPerBlock", Handler: _Msg_SetConsumerFeesPerBlock_Handler, @@ -2192,6 +2347,69 @@ func (m *MsgUpdateParamsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) return len(dAtA) - i, nil } +func (m *MsgUpdateInfractionParams) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgUpdateInfractionParams) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgUpdateInfractionParams) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.InfractionParameters.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + if len(m.Authority) > 0 { + i -= len(m.Authority) + copy(dAtA[i:], m.Authority) + i = encodeVarintTx(dAtA, i, uint64(len(m.Authority))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgUpdateInfractionParamsResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgUpdateInfractionParamsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgUpdateInfractionParamsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + func (m *MsgRemoveConsumer) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -3008,6 +3226,30 @@ func (m *MsgUpdateParamsResponse) Size() (n int) { return n } +func (m *MsgUpdateInfractionParams) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Authority) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = m.InfractionParameters.Size() + n += 1 + l + sovTx(uint64(l)) + return n +} + +func (m *MsgUpdateInfractionParamsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + func (m *MsgRemoveConsumer) Size() (n int) { if m == nil { return 0 @@ -4098,6 +4340,171 @@ func (m *MsgUpdateParamsResponse) Unmarshal(dAtA []byte) error { } return nil } +func (m *MsgUpdateInfractionParams) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgUpdateInfractionParams: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgUpdateInfractionParams: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Authority", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Authority = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field InfractionParameters", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.InfractionParameters.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgUpdateInfractionParamsResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgUpdateInfractionParamsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgUpdateInfractionParamsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func (m *MsgRemoveConsumer) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0