From 4ed2723de4c87d3fa3c37f7a5b72c467e2f77f34 Mon Sep 17 00:00:00 2001 From: Simon Noetzlin Date: Thu, 29 Aug 2024 10:34:02 +0200 Subject: [PATCH] feat: extend consumer chains query (#2172) * feat: first iteration on Permissionless ICS (#2117) * (partially) renamed chain ids to consumer ids * renamed proposal messages * removed global slash entry * fixed unit tests * added new messages * introduced new state * added functionality for the register and initialize messages * renamed (partially) chainIds to consumerIds * set consumerId to chainId association during registration * added extra check in the initialization so unknokwn, launched, or stopped chains cannot re-initialize * added initial work on traversing initialized chains that are to-be-launched * fixed rebase issues after bringing the VSCMaturedPackets work in * made it so we traverse initialization records instead of addition proposals (+ additional changes so the unit tests pass) * renamed more chainIDs to consumerIds * removed ClientIdToChainId state because chainId already resides on the registration record * nit fixes in go docs * removed MsgConsumerAddition * added CLI commands for new messages * removed consumer modification proposal * removed (partially) consumer removal proposal * rebased to pick up the inactive-validators work (PR #2079) * introduced consumerId in the equivocation messages (and a useful query for Hermes to get the consumerId) * added safeguard so that a validator cannot opt-in to two different chains with the same chain id * renamed some chainIDs to consumerIds * updated based on comments Co-authored-by: bernd-m <43466467+bermuell@users.noreply.github.com> * fixed integration tests * rebased to pick up the removal of legacy proposals (#2130) and re-introduced old messages so that existing proposals can deserialize * changes messages to only have MsgCreateConsumer and MsgUpdateConsumer and modified protos so that we are backward-compatible * cleaned up slightly a few things (mostly committing & pushing) so people can pick up the latest changes * fixed the CreateConsumer and UpdateConsumer logic and made most of the fields optional * fixed hooks and the code around proposalId to consumerId * feat: extend consumer validator query to return commission rate (backport #2162) (#2165) * adapt #2162 changes for permissionless ICS * nits --------- Co-authored-by: kirdatatjana <116630536+kirdatatjana@users.noreply.github.com> * renamed some chainIds to consumerIds * took into account comments and also added safeguard to reject new proposals that still use deprecated messages (e.g., MsgConsumerAddition, etc.) * Update x/ccv/provider/types/msg.go Co-authored-by: bernd-m <43466467+bermuell@users.noreply.github.com> * removed double-gas charge on MsgCreateConsumer and imroved the logic of MsgUpdateConsumer * added PopulateMinimumPowerInTopN tested * took into account comments (using protos for marshalling string slice, fixed issues in the UpdateConsumer logic, added extra check to abort spurious proposals) * feat: add fields to consumer validators query (#2167) * extend consumer validators query * nit * nits * fix msg order * deprecate power for consumer_power * modified the way we verify the new owner address, as well as nit refactoring on the ConsumerIds * fixed some rebase issues and changed a proto to be backward-compatible --------- Co-authored-by: bernd-m <43466467+bermuell@users.noreply.github.com> Co-authored-by: Simon Noetzlin Co-authored-by: kirdatatjana <116630536+kirdatatjana@users.noreply.github.com> * add phase + metadata * first logic draft * add filter * reformat test * nits * nit * address comments * update tests * nits * update logic * update CLI * revert unwanted changes * remove filter field * nit * fix bad int conversion * update cli --------- Co-authored-by: insumity Co-authored-by: bernd-m <43466467+bermuell@users.noreply.github.com> Co-authored-by: kirdatatjana <116630536+kirdatatjana@users.noreply.github.com> --- .../ccv/provider/v1/query.proto | 18 +- x/ccv/provider/client/cli/query.go | 27 +- x/ccv/provider/keeper/grpc_query.go | 74 ++- x/ccv/provider/keeper/grpc_query_test.go | 131 ++++- x/ccv/provider/keeper/hooks.go | 3 +- x/ccv/provider/types/query.pb.go | 517 ++++++++++++------ x/ccv/provider/types/query.pb.gw.go | 18 + 7 files changed, 587 insertions(+), 201 deletions(-) diff --git a/proto/interchain_security/ccv/provider/v1/query.proto b/proto/interchain_security/ccv/provider/v1/query.proto index 23ca4c6fee..ddd7805c75 100644 --- a/proto/interchain_security/ccv/provider/v1/query.proto +++ b/proto/interchain_security/ccv/provider/v1/query.proto @@ -199,7 +199,14 @@ message QueryConsumerGenesisResponse { [ (gogoproto.nullable) = false ]; } -message QueryConsumerChainsRequest {} +message QueryConsumerChainsRequest { + // The phase of the consumer chains returned (optional) + // Registered=1|Initialized=2|Launched=3|Stopped=4 + ConsumerPhase phase = 1; + // The limit of consumer chains returned (optional) + // default is 100 + int32 limit = 2; +} message QueryConsumerChainsResponse { repeated Chain chains = 1; } @@ -233,11 +240,14 @@ message Chain { repeated string allowlist = 7; // Corresponds to a list of provider consensus addresses of validators that CANNOT validate the consumer chain. repeated string denylist = 8; + // The phase the consumer chain (Registered=0|Initialized=1|FailedToLaunch=2|Launched=3|Stopped=4) + ConsumerPhase phase = 9; + // The metadata of the consumer chain + ConsumerMetadata metadata = 10 [(gogoproto.nullable) = false ]; // Corresponds to the minimal amount of (provider chain) stake required to validate on the consumer chain. - uint64 min_stake = 9; + uint64 min_stake = 11; // Corresponds to whether inactive validators are allowed to validate the consumer chain. - bool allow_inactive_vals = 10; - + bool allow_inactive_vals = 12; } message QueryValidatorConsumerAddrRequest { diff --git a/x/ccv/provider/client/cli/query.go b/x/ccv/provider/client/cli/query.go index 34d715583c..53f81a90bf 100644 --- a/x/ccv/provider/client/cli/query.go +++ b/x/ccv/provider/client/cli/query.go @@ -2,6 +2,7 @@ package cli import ( "fmt" + "strconv" "strings" "github.com/spf13/cobra" @@ -75,9 +76,12 @@ func CmdConsumerGenesis() *cobra.Command { func CmdConsumerChains() *cobra.Command { cmd := &cobra.Command{ - Use: "list-consumer-chains", - Short: "Query active consumer chains for provider chain.", - Args: cobra.ExactArgs(0), + Use: "list-consumer-chains [phase] [limit]", + Short: "Query consumer chains for provider chain.", + Long: `Query consumer chains for provider chain. An optional + integer parameter can be passed for phase filtering of consumer chains, + (Registered=1|Initialized=2|Launched=3|Stopped=4).`, + Args: cobra.MaximumNArgs(2), RunE: func(cmd *cobra.Command, args []string) (err error) { clientCtx, err := client.GetClientQueryContext(cmd) if err != nil { @@ -86,6 +90,23 @@ func CmdConsumerChains() *cobra.Command { queryClient := types.NewQueryClient(clientCtx) req := &types.QueryConsumerChainsRequest{} + + if args[0] != "" { + phase, err := strconv.ParseInt(args[0], 10, 32) + if err != nil { + return err + } + req.Phase = types.ConsumerPhase(phase) + } + + if args[1] != "" { + limit, err := strconv.ParseInt(args[1], 10, 32) + if err != nil { + return err + } + req.Limit = int32(limit) + } + res, err := queryClient.QueryConsumerChains(cmd.Context(), req) if err != nil { return err diff --git a/x/ccv/provider/keeper/grpc_query.go b/x/ccv/provider/keeper/grpc_query.go index 63ca301775..855f66fe5e 100644 --- a/x/ccv/provider/keeper/grpc_query.go +++ b/x/ccv/provider/keeper/grpc_query.go @@ -5,14 +5,15 @@ import ( "context" "fmt" "sort" + "strconv" "google.golang.org/grpc/codes" "google.golang.org/grpc/status" errorsmod "cosmossdk.io/errors" + "cosmossdk.io/math" sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/cosmos/interchain-security/v5/x/ccv/provider/types" ccvtypes "github.com/cosmos/interchain-security/v5/x/ccv/types" ) @@ -51,13 +52,51 @@ func (k Keeper) QueryConsumerChains(goCtx context.Context, req *types.QueryConsu ctx := sdk.UnwrapSDKContext(goCtx) - chains := []*types.Chain{} - for _, chainID := range k.GetAllRegisteredConsumerIds(ctx) { - c, err := k.GetConsumerChain(ctx, chainID) + consumerIds := []string{} + phaseFilter := req.Phase + + // if the phase filter is set Launched get consumer from the state directly + if phaseFilter == types.ConsumerPhase_CONSUMER_PHASE_LAUNCHED { + consumerIds = append(consumerIds, k.GetAllRegisteredConsumerIds(ctx)...) + // otherwise iterate over all the consumer using the last unused consumer Id + } else { + firstUnusedConsumerId, ok := k.GetConsumerId(ctx) + if !ok { + return &types.QueryConsumerChainsResponse{}, nil + } + for i := uint64(0); i < firstUnusedConsumerId; i++ { + // if the phase filter is set, verify that the consumer has the same phase + if phaseFilter != types.ConsumerPhase_CONSUMER_PHASE_UNSPECIFIED { + p := k.GetConsumerPhase(ctx, strconv.FormatInt(int64(i), 10)) + if p == types.ConsumerPhase_CONSUMER_PHASE_UNSPECIFIED { + return nil, status.Error(codes.Internal, fmt.Sprintf("cannot retrieve phase for consumer id: %d", i)) + } + if p != phaseFilter { + continue + } + } + + consumerIds = append(consumerIds, strconv.FormatInt(int64(i), 10)) + } + } + + // set limit to default value + limit := 100 + if req.Limit != 0 { + // update limit if specified + limit = int(req.Limit) + } + + chains := make([]*types.Chain, math.Min(len(consumerIds), limit)) + for i, cID := range consumerIds { + if i == limit { + break + } + c, err := k.GetConsumerChain(ctx, cID) if err != nil { return nil, status.Error(codes.Internal, err.Error()) } - chains = append(chains, &c) + chains[i] = &c } return &types.QueryConsumerChainsResponse{Chains: chains}, nil @@ -70,11 +109,7 @@ func (k Keeper) GetConsumerChain(ctx sdk.Context, consumerId string) (types.Chai return types.Chain{}, fmt.Errorf("cannot find chainID for consumer (%s)", consumerId) } - clientID, found := k.GetConsumerClientId(ctx, consumerId) - if !found { - return types.Chain{}, fmt.Errorf("cannot find clientID for consumer (%s)", consumerId) - } - + clientID, _ := k.GetConsumerClientId(ctx, consumerId) topN := k.GetTopN(ctx, consumerId) // Get the minimal power in the top N for the consumer chain @@ -84,9 +119,10 @@ func (k Keeper) GetConsumerChain(ctx sdk.Context, consumerId string) (types.Chai minPowerInTopN = -1 } - validatorSetCap := k.GetValidatorSetCap(ctx, consumerId) - - validatorsPowerCap := k.GetValidatorsPowerCap(ctx, consumerId) + phase := k.GetConsumerPhase(ctx, consumerId) + if phase == types.ConsumerPhase_CONSUMER_PHASE_UNSPECIFIED { + return types.Chain{}, fmt.Errorf("cannot find phase for consumer (%s)", consumerId) + } allowlist := k.GetAllowList(ctx, consumerId) strAllowlist := make([]string, len(allowlist)) @@ -100,8 +136,12 @@ func (k Keeper) GetConsumerChain(ctx sdk.Context, consumerId string) (types.Chai strDenylist[i] = addr.String() } - allowInactiveVals := k.AllowsInactiveValidators(ctx, consumerId) + metadata, err := k.GetConsumerMetadata(ctx, consumerId) + if err != nil { + return types.Chain{}, fmt.Errorf("cannot get metadata for consumer (%s): %w", consumerId, err) + } + allowInactiveVals := k.AllowsInactiveValidators(ctx, consumerId) minStake := k.GetMinStake(ctx, consumerId) return types.Chain{ @@ -109,10 +149,12 @@ func (k Keeper) GetConsumerChain(ctx sdk.Context, consumerId string) (types.Chai ClientId: clientID, Top_N: topN, MinPowerInTop_N: minPowerInTopN, - ValidatorSetCap: validatorSetCap, - ValidatorsPowerCap: validatorsPowerCap, + ValidatorSetCap: k.GetValidatorSetCap(ctx, consumerId), + ValidatorsPowerCap: k.GetValidatorsPowerCap(ctx, consumerId), Allowlist: strAllowlist, Denylist: strDenylist, + Phase: phase, + Metadata: metadata, AllowInactiveVals: allowInactiveVals, MinStake: minStake, }, nil diff --git a/x/ccv/provider/keeper/grpc_query_test.go b/x/ccv/provider/keeper/grpc_query_test.go index 7a0e62c3f7..a618a66d84 100644 --- a/x/ccv/provider/keeper/grpc_query_test.go +++ b/x/ccv/provider/keeper/grpc_query_test.go @@ -4,7 +4,9 @@ import ( "bytes" "fmt" "sort" + "strconv" "testing" + "time" "github.com/golang/mock/gomock" "github.com/stretchr/testify/require" @@ -18,6 +20,7 @@ import ( cryptotestutil "github.com/cosmos/interchain-security/v5/testutil/crypto" testkeeper "github.com/cosmos/interchain-security/v5/testutil/keeper" + "github.com/cosmos/interchain-security/v5/x/ccv/provider/keeper" "github.com/cosmos/interchain-security/v5/x/ccv/provider/types" ccvtypes "github.com/cosmos/interchain-security/v5/x/ccv/types" ) @@ -427,6 +430,8 @@ func TestGetConsumerChain(t *testing.T) { math.NewInt(300), } + metadataLists := []types.ConsumerMetadata{} + expectedGetAllOrder := []types.Chain{} for i, consumerID := range consumerIDs { pk.SetConsumerChainId(ctx, consumerID, chainIDs[i]) @@ -437,6 +442,8 @@ func TestGetConsumerChain(t *testing.T) { Top_N: topN, ValidatorSetCap: validatorSetCaps[i], ValidatorsPowerCap: validatorPowerCaps[i], + MinStake: minStakes[i].Uint64(), + AllowInactiveVals: allowInactiveVals[i], }) pk.SetMinimumPowerInTopN(ctx, consumerID, expectedMinPowerInTopNs[i]) for _, addr := range allowlists[i] { @@ -455,6 +462,12 @@ func TestGetConsumerChain(t *testing.T) { strDenylist[j] = addr.String() } + metadataLists = append(metadataLists, types.ConsumerMetadata{Name: chainIDs[i]}) + pk.SetConsumerMetadata(ctx, consumerID, metadataLists[i]) + + phase := types.ConsumerPhase(int32(i + 1)) + pk.SetConsumerPhase(ctx, consumerID, phase) + expectedGetAllOrder = append(expectedGetAllOrder, types.Chain{ ChainId: chainIDs[i], @@ -465,13 +478,15 @@ func TestGetConsumerChain(t *testing.T) { ValidatorsPowerCap: validatorPowerCaps[i], Allowlist: strAllowlist, Denylist: strDenylist, + Phase: phase, + Metadata: metadataLists[i], AllowInactiveVals: allowInactiveVals[i], MinStake: minStakes[i].Uint64(), }) } - for i, chainID := range pk.GetAllActiveConsumerIds(ctx) { - c, err := pk.GetConsumerChain(ctx, chainID) + for i, cId := range consumerIDs { + c, err := pk.GetConsumerChain(ctx, cId) require.NoError(t, err) require.Equal(t, expectedGetAllOrder[i], c) } @@ -562,3 +577,115 @@ func TestQueryConsumerIdFromClientId(t *testing.T) { require.NoError(t, err) require.Equal(t, expectedConsumerId, res.ConsumerId) } + +func TestQueryConsumerChains(t *testing.T) { + pk, ctx, ctrl, _ := testkeeper.GetProviderKeeperAndCtx(t, testkeeper.NewInMemKeeperParams(t)) + defer ctrl.Finish() + + consumerNum := 4 + consumerIds := make([]string, consumerNum) + consumers := make([]*types.Chain, consumerNum) + + // expect no error and returned chains + res, err := pk.QueryConsumerChains(ctx, &types.QueryConsumerChainsRequest{}) + require.NoError(t, err) + require.Len(t, res.Chains, 0) + + // create four consumer chains in different phase + for i := 0; i < consumerNum; i++ { + cID := pk.FetchAndIncrementConsumerId(ctx) + chainID := "consumer-" + strconv.Itoa(i) + c := types.Chain{ + ChainId: chainID, + MinPowerInTop_N: -1, + ValidatorsPowerCap: 0, + ValidatorSetCap: 0, + Allowlist: []string{}, + Denylist: []string{}, + Phase: types.ConsumerPhase(i + 1), + Metadata: types.ConsumerMetadata{Name: chainID}, + } + pk.SetConsumerPhase(ctx, cID, c.Phase) + pk.SetConsumerMetadata(ctx, cID, c.Metadata) + pk.SetConsumerChainId(ctx, cID, chainID) + + consumerIds[i] = cID + consumers[i] = &c + } + + testCases := []struct { + name string + setup func(ctx sdk.Context, pk keeper.Keeper) + phase_filter types.ConsumerPhase + limit int32 + expConsumers []*types.Chain + }{ + { + name: "expect all consumers when phase filter isn't set", + setup: func(ctx sdk.Context, pk keeper.Keeper) {}, + expConsumers: consumers, + }, + { + name: "expect an amount of consumer equal to the limit", + setup: func(ctx sdk.Context, pk keeper.Keeper) {}, + expConsumers: consumers[:3], + limit: int32(3), + }, + { + name: "expect registered consumers when phase filter is set to Registered", + setup: func(ctx sdk.Context, pk keeper.Keeper) { + consumers[0].Phase = types.ConsumerPhase_CONSUMER_PHASE_REGISTERED + pk.SetConsumerPhase(ctx, consumerIds[0], types.ConsumerPhase_CONSUMER_PHASE_REGISTERED) + }, + phase_filter: types.ConsumerPhase_CONSUMER_PHASE_REGISTERED, + expConsumers: consumers[0:1], + }, + { + name: "expect initialized consumers when phase is set to Initialized", + setup: func(ctx sdk.Context, pk keeper.Keeper) { + consumers[1].Phase = types.ConsumerPhase_CONSUMER_PHASE_INITIALIZED + err := pk.AppendConsumerToBeLaunchedOnSpawnTime(ctx, consumerIds[1], time.Now()) + require.NoError(t, err) + pk.SetConsumerPhase(ctx, consumerIds[1], types.ConsumerPhase_CONSUMER_PHASE_INITIALIZED) + }, + phase_filter: types.ConsumerPhase_CONSUMER_PHASE_INITIALIZED, + expConsumers: consumers[1:2], + }, + { + name: "expect launched consumers when phase is set to Launched", + setup: func(ctx sdk.Context, pk keeper.Keeper) { + consumers[2].Phase = types.ConsumerPhase_CONSUMER_PHASE_LAUNCHED + consumers[2].ClientId = "ClientID" + pk.SetConsumerClientId(ctx, consumerIds[2], consumers[2].ClientId) + pk.SetConsumerPhase(ctx, consumerIds[2], types.ConsumerPhase_CONSUMER_PHASE_LAUNCHED) + }, + phase_filter: types.ConsumerPhase_CONSUMER_PHASE_LAUNCHED, + expConsumers: consumers[2:3], + }, + { + name: "expect stopped consumers when phase is set to Stopped", + setup: func(ctx sdk.Context, pk keeper.Keeper) { + consumers[3].Phase = types.ConsumerPhase_CONSUMER_PHASE_STOPPED + pk.SetConsumerPhase(ctx, consumerIds[3], types.ConsumerPhase_CONSUMER_PHASE_STOPPED) + }, + phase_filter: types.ConsumerPhase_CONSUMER_PHASE_STOPPED, + expConsumers: consumers[3:], + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + tc.setup(ctx, pk) + req := types.QueryConsumerChainsRequest{ + Phase: tc.phase_filter, + Limit: tc.limit, + } + expectedResponse := types.QueryConsumerChainsResponse{ + Chains: tc.expConsumers, + } + res, err := pk.QueryConsumerChains(ctx, &req) + require.NoError(t, err) + require.Equal(t, &expectedResponse, res) + }) + } +} diff --git a/x/ccv/provider/keeper/hooks.go b/x/ccv/provider/keeper/hooks.go index 68bcbbc399..ffb1b46c15 100644 --- a/x/ccv/provider/keeper/hooks.go +++ b/x/ccv/provider/keeper/hooks.go @@ -2,8 +2,9 @@ package keeper import ( "context" - "cosmossdk.io/math" "fmt" + + "cosmossdk.io/math" sdk "github.com/cosmos/cosmos-sdk/types" sdkgov "github.com/cosmos/cosmos-sdk/x/gov/types" stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" diff --git a/x/ccv/provider/types/query.pb.go b/x/ccv/provider/types/query.pb.go index 25c51440cc..568b8d34ae 100644 --- a/x/ccv/provider/types/query.pb.go +++ b/x/ccv/provider/types/query.pb.go @@ -137,6 +137,12 @@ func (m *QueryConsumerGenesisResponse) GetGenesisState() types.ConsumerGenesisSt } type QueryConsumerChainsRequest struct { + // The phase of the consumer chains returned (optional) + // Registered=1|Initialized=2|Launched=3|Stopped=4 + Phase ConsumerPhase `protobuf:"varint,1,opt,name=phase,proto3,enum=interchain_security.ccv.provider.v1.ConsumerPhase" json:"phase,omitempty"` + // The limit of consumer chains returned (optional) + // default is 100 + Limit int32 `protobuf:"varint,2,opt,name=limit,proto3" json:"limit,omitempty"` } func (m *QueryConsumerChainsRequest) Reset() { *m = QueryConsumerChainsRequest{} } @@ -172,6 +178,20 @@ func (m *QueryConsumerChainsRequest) XXX_DiscardUnknown() { var xxx_messageInfo_QueryConsumerChainsRequest proto.InternalMessageInfo +func (m *QueryConsumerChainsRequest) GetPhase() ConsumerPhase { + if m != nil { + return m.Phase + } + return ConsumerPhase_CONSUMER_PHASE_UNSPECIFIED +} + +func (m *QueryConsumerChainsRequest) GetLimit() int32 { + if m != nil { + return m.Limit + } + return 0 +} + type QueryConsumerChainsResponse struct { Chains []*Chain `protobuf:"bytes,1,rep,name=chains,proto3" json:"chains,omitempty"` } @@ -402,10 +422,14 @@ type Chain struct { Allowlist []string `protobuf:"bytes,7,rep,name=allowlist,proto3" json:"allowlist,omitempty"` // Corresponds to a list of provider consensus addresses of validators that CANNOT validate the consumer chain. Denylist []string `protobuf:"bytes,8,rep,name=denylist,proto3" json:"denylist,omitempty"` + // The phase the consumer chain (Registered=0|Initialized=1|FailedToLaunch=2|Launched=3|Stopped=4) + Phase ConsumerPhase `protobuf:"varint,9,opt,name=phase,proto3,enum=interchain_security.ccv.provider.v1.ConsumerPhase" json:"phase,omitempty"` + // The metadata of the consumer chain + Metadata ConsumerMetadata `protobuf:"bytes,10,opt,name=metadata,proto3" json:"metadata"` // Corresponds to the minimal amount of (provider chain) stake required to validate on the consumer chain. - MinStake uint64 `protobuf:"varint,9,opt,name=min_stake,json=minStake,proto3" json:"min_stake,omitempty"` + MinStake uint64 `protobuf:"varint,11,opt,name=min_stake,json=minStake,proto3" json:"min_stake,omitempty"` // Corresponds to whether inactive validators are allowed to validate the consumer chain. - AllowInactiveVals bool `protobuf:"varint,10,opt,name=allow_inactive_vals,json=allowInactiveVals,proto3" json:"allow_inactive_vals,omitempty"` + AllowInactiveVals bool `protobuf:"varint,12,opt,name=allow_inactive_vals,json=allowInactiveVals,proto3" json:"allow_inactive_vals,omitempty"` } func (m *Chain) Reset() { *m = Chain{} } @@ -497,6 +521,20 @@ func (m *Chain) GetDenylist() []string { return nil } +func (m *Chain) GetPhase() ConsumerPhase { + if m != nil { + return m.Phase + } + return ConsumerPhase_CONSUMER_PHASE_UNSPECIFIED +} + +func (m *Chain) GetMetadata() ConsumerMetadata { + if m != nil { + return m.Metadata + } + return ConsumerMetadata{} +} + func (m *Chain) GetMinStake() uint64 { if m != nil { return m.MinStake @@ -2159,172 +2197,175 @@ func init() { } var fileDescriptor_422512d7b7586cd7 = []byte{ - // 2637 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x5a, 0x4b, 0x6c, 0x1c, 0x49, - 0x19, 0x76, 0x8f, 0x1f, 0xb1, 0xcb, 0xb1, 0xb3, 0xa9, 0x38, 0xc9, 0x64, 0xec, 0x78, 0x9c, 0xce, - 0x06, 0x26, 0xaf, 0x19, 0xdb, 0xab, 0xb0, 0x9b, 0xec, 0xe6, 0xe1, 0x19, 0xc7, 0xc9, 0x28, 0x2f, - 0x6f, 0xdb, 0xc9, 0x22, 0x2f, 0xa1, 0x53, 0xee, 0xae, 0x1d, 0x37, 0x9e, 0xe9, 0x6e, 0x77, 0x95, - 0xc7, 0x19, 0xa2, 0x1c, 0x16, 0x24, 0xb4, 0x70, 0x40, 0x41, 0x88, 0xfb, 0x0a, 0x09, 0x89, 0x03, - 0x27, 0xb4, 0x02, 0x71, 0xdb, 0xe3, 0xde, 0x58, 0x76, 0x2f, 0x08, 0x44, 0x40, 0x09, 0x48, 0x80, - 0x84, 0x84, 0x16, 0xae, 0x48, 0xa8, 0xab, 0xab, 0x7b, 0xba, 0x7b, 0x7a, 0x3c, 0xdd, 0x33, 0x3e, - 0xec, 0xcd, 0x5d, 0xf5, 0xd7, 0xf7, 0x3f, 0xea, 0xaf, 0xbf, 0xfe, 0xfa, 0x3c, 0xa0, 0xa0, 0xe9, - 0x14, 0x5b, 0xca, 0x06, 0xd2, 0x74, 0x99, 0x60, 0x65, 0xdb, 0xd2, 0x68, 0xa3, 0xa0, 0x28, 0xf5, - 0x82, 0x69, 0x19, 0x75, 0x4d, 0xc5, 0x56, 0xa1, 0x3e, 0x57, 0xd8, 0xda, 0xc6, 0x56, 0x23, 0x6f, - 0x5a, 0x06, 0x35, 0xe0, 0xc9, 0x88, 0x05, 0x79, 0x45, 0xa9, 0xe7, 0xdd, 0x05, 0xf9, 0xfa, 0x5c, - 0x66, 0xaa, 0x62, 0x18, 0x95, 0x2a, 0x2e, 0x20, 0x53, 0x2b, 0x20, 0x5d, 0x37, 0x28, 0xa2, 0x9a, - 0xa1, 0x13, 0x07, 0x22, 0x33, 0x51, 0x31, 0x2a, 0x06, 0xfb, 0xb3, 0x60, 0xff, 0xc5, 0x47, 0xb3, - 0x7c, 0x0d, 0xfb, 0x5a, 0xdf, 0x7e, 0xaf, 0x40, 0xb5, 0x1a, 0x26, 0x14, 0xd5, 0x4c, 0x2e, 0x30, - 0x1f, 0xc7, 0x54, 0xcf, 0x0a, 0x67, 0xcd, 0x6c, 0xbb, 0x35, 0xf5, 0xb9, 0x02, 0xd9, 0x40, 0x16, - 0x56, 0x65, 0xc5, 0xd0, 0xc9, 0x76, 0xcd, 0x5b, 0x71, 0x6a, 0x97, 0x15, 0x3b, 0x9a, 0x85, 0xb9, - 0xd8, 0x14, 0xc5, 0xba, 0x8a, 0xad, 0x9a, 0xa6, 0xd3, 0x82, 0x62, 0x35, 0x4c, 0x6a, 0x14, 0x36, - 0x71, 0xc3, 0xf5, 0xf0, 0x98, 0x62, 0x90, 0x9a, 0x41, 0x64, 0xc7, 0x49, 0xe7, 0x83, 0x4f, 0xbd, - 0xea, 0x7c, 0x15, 0x08, 0x45, 0x9b, 0x9a, 0x5e, 0x29, 0xd4, 0xe7, 0xd6, 0x31, 0x45, 0x73, 0xee, - 0xb7, 0x23, 0x25, 0x3e, 0x04, 0x93, 0x6f, 0xdb, 0x41, 0x2f, 0x71, 0xe3, 0x6e, 0x60, 0x1d, 0x13, - 0x8d, 0x48, 0x78, 0x6b, 0x1b, 0x13, 0x0a, 0x8f, 0x83, 0x61, 0xc7, 0x42, 0x4d, 0x4d, 0x0b, 0x33, - 0x42, 0x6e, 0xa4, 0x98, 0x4a, 0x0b, 0xd2, 0x3e, 0x36, 0x56, 0x56, 0x61, 0x16, 0x8c, 0xba, 0x5e, - 0xd9, 0x12, 0x29, 0x5b, 0x42, 0x02, 0xee, 0x50, 0x59, 0x15, 0x9f, 0x80, 0xa9, 0x68, 0x78, 0x62, - 0x1a, 0x3a, 0xc1, 0xf0, 0x5d, 0x30, 0x56, 0x71, 0x86, 0x64, 0x42, 0x11, 0xc5, 0x4c, 0xc9, 0xe8, - 0xfc, 0x6c, 0xbe, 0xdd, 0xe6, 0xd7, 0xe7, 0xf2, 0x21, 0xac, 0x15, 0x7b, 0x5d, 0x71, 0xe0, 0x93, - 0xe7, 0xd9, 0x3e, 0x69, 0x7f, 0xc5, 0x37, 0x26, 0x4e, 0x81, 0x4c, 0x40, 0x79, 0xc9, 0x86, 0x73, - 0x5d, 0x13, 0x51, 0xc8, 0x73, 0x77, 0x96, 0x5b, 0x56, 0x04, 0x43, 0x4c, 0x3d, 0x49, 0x0b, 0x33, - 0xfd, 0xb9, 0xd1, 0xf9, 0x33, 0xf9, 0x18, 0xf9, 0x98, 0x67, 0x20, 0x12, 0x5f, 0x29, 0x9e, 0x06, - 0x5f, 0x6d, 0x55, 0xb1, 0x42, 0x91, 0x45, 0x97, 0x2d, 0xc3, 0x34, 0x08, 0xaa, 0x7a, 0xd6, 0x7c, - 0x20, 0x80, 0x5c, 0x67, 0x59, 0x6e, 0xdb, 0x37, 0xc0, 0x88, 0xe9, 0x0e, 0xf2, 0x88, 0x5d, 0x89, - 0x67, 0x1e, 0x07, 0x5f, 0x50, 0x55, 0xcd, 0x3e, 0x28, 0x4d, 0xe8, 0x26, 0xa0, 0x98, 0x03, 0x5f, - 0x89, 0xb2, 0xc4, 0x30, 0x5b, 0x8c, 0xfe, 0x9e, 0x10, 0xed, 0x60, 0x40, 0xd4, 0xdb, 0xe9, 0x16, - 0x9b, 0x2f, 0x27, 0xb2, 0x59, 0xc2, 0x35, 0xa3, 0x8e, 0xaa, 0x91, 0x26, 0xff, 0x2d, 0x05, 0x06, - 0x99, 0x6e, 0x78, 0x2c, 0x9c, 0xb0, 0xcd, 0x64, 0x9d, 0x04, 0x23, 0x4a, 0x55, 0xc3, 0x3a, 0x6d, - 0xa6, 0xea, 0xb0, 0x33, 0x50, 0x56, 0xe1, 0x21, 0x30, 0x48, 0x0d, 0x53, 0xbe, 0x9b, 0xee, 0x9f, - 0x11, 0x72, 0x63, 0xd2, 0x00, 0x35, 0xcc, 0xbb, 0xf0, 0x0c, 0x80, 0x35, 0x4d, 0x97, 0x4d, 0x63, - 0xc7, 0xce, 0x6f, 0x5d, 0x76, 0x24, 0x06, 0x66, 0x84, 0x5c, 0xbf, 0x34, 0x5e, 0xd3, 0xf4, 0x65, - 0x7b, 0xa2, 0xac, 0xaf, 0xda, 0xb2, 0xb3, 0x60, 0xa2, 0x8e, 0xaa, 0x9a, 0x8a, 0xa8, 0x61, 0x11, - 0xbe, 0x44, 0x41, 0x66, 0x7a, 0x90, 0xe1, 0xc1, 0xe6, 0x1c, 0x5b, 0x54, 0x42, 0x26, 0x3c, 0x03, - 0x0e, 0x7a, 0xa3, 0x32, 0xc1, 0x94, 0x89, 0x0f, 0x31, 0xf1, 0x03, 0xde, 0xc4, 0x0a, 0xa6, 0xb6, - 0xec, 0x14, 0x18, 0x41, 0xd5, 0xaa, 0xb1, 0x53, 0xd5, 0x08, 0x4d, 0xef, 0x9b, 0xe9, 0xcf, 0x8d, - 0x48, 0xcd, 0x01, 0x98, 0x01, 0xc3, 0x2a, 0xd6, 0x1b, 0x6c, 0x72, 0x98, 0x4d, 0x7a, 0xdf, 0xb6, - 0xd7, 0xb6, 0x0f, 0xf6, 0xa9, 0xc7, 0xe9, 0x91, 0x19, 0x21, 0x37, 0x20, 0x0d, 0xd7, 0x58, 0x66, - 0x6d, 0x62, 0x98, 0x07, 0x87, 0x18, 0x8a, 0xac, 0xe9, 0x48, 0xa1, 0x5a, 0x1d, 0xcb, 0x75, 0x7b, - 0x7b, 0xc0, 0x8c, 0x90, 0x1b, 0x96, 0x0e, 0xb2, 0xa9, 0x32, 0x9f, 0x79, 0x60, 0xc7, 0xf9, 0x17, - 0x02, 0x38, 0xc1, 0x36, 0xfc, 0x81, 0x6b, 0x9f, 0x2f, 0xa3, 0xac, 0x98, 0x45, 0xe3, 0x32, 0x78, - 0xc5, 0xdd, 0x5f, 0x19, 0xa9, 0xaa, 0x85, 0x09, 0x71, 0xb6, 0xa3, 0x08, 0xbf, 0x78, 0x9e, 0x1d, - 0x6f, 0xa0, 0x5a, 0xf5, 0x92, 0xc8, 0x27, 0x44, 0xe9, 0x80, 0x2b, 0xbb, 0xe0, 0x8c, 0x84, 0x6b, - 0x4e, 0x7f, 0xb8, 0xe6, 0x5c, 0x1a, 0xfe, 0xe0, 0xc3, 0x6c, 0xdf, 0xdf, 0x3f, 0xcc, 0xf6, 0x89, - 0xf7, 0x80, 0xb8, 0x9b, 0xb5, 0x3c, 0x33, 0x4f, 0x83, 0x57, 0x3c, 0x40, 0xd7, 0x1e, 0x27, 0x75, - 0x0e, 0x28, 0x3e, 0x79, 0xdb, 0x9a, 0x56, 0xff, 0x97, 0x7d, 0xd6, 0xc5, 0xf7, 0xbf, 0x45, 0xdf, - 0x2e, 0xfe, 0x87, 0x6c, 0xe8, 0xc9, 0xff, 0xa0, 0xb5, 0x4d, 0xff, 0x5b, 0xf6, 0x83, 0xfb, 0x1f, - 0x8a, 0xbd, 0x38, 0x09, 0x8e, 0x31, 0xc0, 0xd5, 0x0d, 0xcb, 0xa0, 0xb4, 0x8a, 0x59, 0x9d, 0x75, - 0xab, 0xc1, 0xef, 0x04, 0x5e, 0x6f, 0x43, 0xb3, 0x5c, 0x4d, 0x16, 0x8c, 0x92, 0x2a, 0x22, 0x1b, - 0x72, 0x0d, 0x53, 0x6c, 0x31, 0x0d, 0xfd, 0x12, 0x60, 0x43, 0x77, 0xec, 0x11, 0x38, 0x0f, 0x0e, - 0xfb, 0x04, 0x64, 0x96, 0x7d, 0x48, 0x57, 0x30, 0x0b, 0x4e, 0xbf, 0x74, 0xa8, 0x29, 0xba, 0xe0, - 0x4e, 0xc1, 0x6f, 0x82, 0xb4, 0x8e, 0x1f, 0x53, 0xd9, 0xc2, 0x66, 0x15, 0xeb, 0x1a, 0xd9, 0x90, - 0x15, 0xa4, 0xab, 0xb6, 0xb3, 0x98, 0x45, 0x66, 0x74, 0x3e, 0x93, 0x77, 0xae, 0xfb, 0xbc, 0x7b, - 0xdd, 0xe7, 0x57, 0xdd, 0xeb, 0xbe, 0x38, 0x6c, 0x5f, 0x1a, 0xcf, 0xfe, 0x9c, 0x15, 0xa4, 0x23, - 0x36, 0x8a, 0xe4, 0x82, 0x94, 0x5c, 0x0c, 0xf1, 0x1c, 0x38, 0xc3, 0x5c, 0x92, 0x70, 0x45, 0x23, - 0x14, 0x5b, 0x58, 0x6d, 0x96, 0xa3, 0x1d, 0x64, 0xa9, 0x8b, 0x58, 0x37, 0x6a, 0x5e, 0x3d, 0xbc, - 0x0e, 0xce, 0xc6, 0x92, 0xe6, 0x11, 0x39, 0x02, 0x86, 0x54, 0x36, 0xc2, 0xae, 0x98, 0x11, 0x89, - 0x7f, 0x89, 0xd3, 0xfc, 0xd2, 0x74, 0x4a, 0x1d, 0x56, 0x59, 0x65, 0x2b, 0x2f, 0x7a, 0x6a, 0xde, - 0x17, 0xc0, 0xf1, 0x36, 0x02, 0x1c, 0xf9, 0x11, 0x18, 0x37, 0xfd, 0x73, 0xee, 0x25, 0x36, 0x1f, - 0xab, 0xe2, 0x06, 0x60, 0xf9, 0xcd, 0x1a, 0xc2, 0x13, 0x75, 0x30, 0x16, 0x10, 0x83, 0x53, 0x80, - 0x27, 0xf8, 0x62, 0x6b, 0xce, 0x2f, 0xc2, 0x69, 0x00, 0xdc, 0x6a, 0x5d, 0x5e, 0x64, 0x1b, 0x3a, - 0x20, 0xf9, 0x46, 0x3a, 0x26, 0xb5, 0xb8, 0x05, 0x0a, 0xcc, 0xe5, 0x85, 0x6a, 0x75, 0x19, 0x69, - 0x16, 0x79, 0x80, 0xaa, 0x25, 0x43, 0xb7, 0xf3, 0xb2, 0x18, 0xbc, 0x7d, 0xca, 0x8b, 0x7b, 0xd5, - 0xbb, 0xfc, 0x4c, 0x00, 0xb3, 0xf1, 0x75, 0xf2, 0xc8, 0x6f, 0x81, 0x83, 0x26, 0xd2, 0x2c, 0xbb, - 0x8e, 0xda, 0x0d, 0x1f, 0x3b, 0x50, 0x3c, 0xf8, 0x4b, 0xf1, 0x82, 0x8f, 0x34, 0xab, 0xa9, 0xc8, - 0x3b, 0xb0, 0x7a, 0x33, 0x95, 0xc6, 0xcd, 0x80, 0x88, 0xf8, 0x5f, 0x01, 0x9c, 0xe8, 0xb8, 0x0a, - 0x2e, 0xb5, 0x3b, 0xe5, 0xc5, 0xc9, 0x2f, 0x9e, 0x67, 0x8f, 0x3a, 0x55, 0x27, 0x2c, 0x11, 0x51, - 0x7e, 0x97, 0xda, 0x56, 0x2f, 0x1f, 0x4e, 0x58, 0x22, 0xa2, 0x8c, 0x5d, 0x05, 0xfb, 0x3d, 0xa9, - 0x4d, 0xdc, 0xe0, 0xa7, 0x75, 0x2a, 0xdf, 0x6c, 0x77, 0xf3, 0x4e, 0xbb, 0x9b, 0x5f, 0xde, 0x5e, - 0xaf, 0x6a, 0xca, 0x2d, 0xdc, 0x90, 0xbc, 0x0d, 0xbb, 0x85, 0x1b, 0xe2, 0x04, 0x80, 0xce, 0x21, - 0x40, 0x16, 0x6a, 0x1e, 0xc1, 0x47, 0xe0, 0x50, 0x60, 0x94, 0x6f, 0x4b, 0x19, 0x0c, 0x99, 0x6c, - 0x84, 0xb7, 0x1e, 0x67, 0x63, 0xee, 0x85, 0xbd, 0x84, 0x9f, 0x00, 0x0e, 0x20, 0x56, 0x79, 0x49, - 0x08, 0x64, 0xc0, 0x3d, 0x93, 0x62, 0xb5, 0xac, 0x7b, 0x85, 0x76, 0xcf, 0x1a, 0xe8, 0x2d, 0x5e, - 0x52, 0x3a, 0x69, 0xf3, 0xba, 0xd6, 0xe3, 0xfe, 0x2e, 0x24, 0xb4, 0x9d, 0xd8, 0xad, 0x34, 0x93, - 0xbe, 0x76, 0x24, 0xb8, 0xbf, 0x98, 0x88, 0x8f, 0xc0, 0x74, 0x40, 0xe5, 0xde, 0x3b, 0xf5, 0xa3, - 0x7d, 0x60, 0xa6, 0x8d, 0x0a, 0xef, 0xaf, 0xc8, 0x36, 0x41, 0x88, 0xdf, 0x26, 0x84, 0xf3, 0x2b, - 0x95, 0x30, 0xbf, 0x60, 0x1a, 0x0c, 0xb2, 0x2e, 0x8e, 0x65, 0x66, 0x3f, 0xf3, 0xd0, 0x19, 0x80, - 0x17, 0xc1, 0x80, 0x65, 0x5f, 0x30, 0x03, 0xcc, 0x9a, 0x53, 0x76, 0x76, 0xfc, 0xe1, 0x79, 0x76, - 0xd2, 0x79, 0x6f, 0x11, 0x75, 0x33, 0xaf, 0x19, 0x85, 0x1a, 0xa2, 0x1b, 0xf9, 0xdb, 0xb8, 0x82, - 0x94, 0xc6, 0x22, 0x56, 0xd2, 0x82, 0xc4, 0x96, 0xc0, 0x53, 0x60, 0xdc, 0xb3, 0xca, 0x41, 0x1f, - 0x64, 0x97, 0xdb, 0x98, 0x3b, 0xca, 0xba, 0x43, 0xf8, 0x10, 0xa4, 0x3d, 0x31, 0xc5, 0xa8, 0xd5, - 0x34, 0x42, 0x34, 0x43, 0x97, 0x99, 0xd6, 0x21, 0xa6, 0xf5, 0x64, 0x0c, 0xad, 0xd2, 0x11, 0x17, - 0xa4, 0xe4, 0x61, 0x48, 0xb6, 0x15, 0x0f, 0x41, 0xda, 0x0b, 0x6d, 0x18, 0x7e, 0x5f, 0x02, 0x78, - 0x17, 0x24, 0x04, 0x7f, 0x0b, 0x8c, 0xaa, 0x98, 0x28, 0x96, 0x66, 0xda, 0x6f, 0x8c, 0xf4, 0x30, - 0x8b, 0xfc, 0xc9, 0x3c, 0x7f, 0x9d, 0xba, 0xef, 0x4f, 0xfe, 0x1e, 0xcd, 0x2f, 0x36, 0x45, 0xf9, - 0x49, 0xf3, 0xaf, 0x86, 0x0f, 0xc1, 0x31, 0xcf, 0x56, 0xc3, 0xc4, 0x16, 0xeb, 0x96, 0xdd, 0x7c, - 0x18, 0x61, 0xc6, 0x9e, 0xf8, 0xec, 0xa3, 0xf3, 0xc7, 0x39, 0xba, 0x97, 0x3f, 0x3c, 0x0f, 0x56, - 0xa8, 0xa5, 0xe9, 0x15, 0xe9, 0xa8, 0x8b, 0x71, 0x8f, 0x43, 0xb8, 0x69, 0x72, 0x04, 0x0c, 0x7d, - 0x0b, 0x69, 0x55, 0xac, 0xf2, 0xa6, 0x97, 0x7f, 0xc1, 0x4b, 0x60, 0xc8, 0x7e, 0x90, 0x6e, 0x93, - 0xf4, 0xe8, 0x8c, 0x90, 0x1b, 0x9f, 0x17, 0xdb, 0x99, 0x5f, 0x34, 0x74, 0x75, 0x85, 0x49, 0x4a, - 0x7c, 0x05, 0x5c, 0x05, 0x5e, 0x36, 0xca, 0xd4, 0xd8, 0xc4, 0x3a, 0x49, 0xef, 0x67, 0x86, 0x9e, - 0xe5, 0x51, 0x3d, 0xdc, 0x1a, 0xd5, 0xb2, 0x4e, 0x3f, 0xfb, 0xe8, 0x3c, 0xe0, 0x4a, 0xca, 0x3a, - 0x65, 0x37, 0x2e, 0xc3, 0x58, 0x65, 0x10, 0x76, 0xea, 0x78, 0xa8, 0x4e, 0xea, 0x8c, 0x39, 0xa9, - 0xe3, 0x8e, 0x3a, 0xa9, 0xf3, 0x35, 0x70, 0x94, 0x1f, 0x6e, 0x4c, 0x64, 0x65, 0xdb, 0xb2, 0xec, - 0x07, 0x0f, 0x36, 0x0d, 0x65, 0x23, 0x3d, 0xce, 0x3c, 0x3c, 0xec, 0x4d, 0x97, 0x9c, 0xd9, 0xeb, - 0xf6, 0xa4, 0xfd, 0x00, 0xcd, 0xb6, 0x3d, 0xf6, 0xbc, 0xba, 0x60, 0x00, 0x9a, 0x85, 0x83, 0xdf, - 0x6a, 0xd7, 0x63, 0x55, 0xd2, 0x4e, 0xa7, 0x5d, 0xf2, 0x01, 0x8b, 0x5b, 0xfc, 0xde, 0x0d, 0xbe, - 0xcc, 0x3d, 0xd9, 0x9b, 0x88, 0xac, 0x1a, 0xfc, 0xcb, 0x6d, 0x3e, 0x7b, 0xac, 0x16, 0x22, 0x02, - 0x73, 0x09, 0x54, 0xf2, 0x70, 0x9c, 0x03, 0xb0, 0x79, 0x4a, 0x79, 0x3d, 0x74, 0x2b, 0xac, 0x77, - 0x49, 0x3a, 0x0d, 0x82, 0xca, 0xde, 0x0e, 0x67, 0xa3, 0x5f, 0x23, 0xc1, 0xe3, 0xf3, 0xe5, 0x78, - 0x45, 0x89, 0x15, 0x70, 0x2e, 0x9e, 0xb5, 0x3c, 0x18, 0xaf, 0xf3, 0xa2, 0x28, 0xc4, 0xaf, 0x1f, - 0x6c, 0x81, 0x28, 0xf2, 0xbb, 0xa0, 0x58, 0x35, 0x94, 0x4d, 0x72, 0x5f, 0xa7, 0x5a, 0xf5, 0x2e, - 0x7e, 0xec, 0x64, 0xa5, 0x7b, 0xab, 0xaf, 0xf1, 0x67, 0x57, 0xb4, 0x0c, 0xb7, 0xe0, 0x02, 0x38, - 0xba, 0xce, 0xe6, 0xe5, 0x6d, 0x5b, 0x40, 0x66, 0x0f, 0x03, 0x27, 0xf3, 0x05, 0xd6, 0x70, 0x4e, - 0xac, 0x47, 0x2c, 0x17, 0x17, 0xf8, 0x23, 0xa9, 0xe4, 0xf9, 0xbe, 0x64, 0x19, 0xb5, 0x12, 0x27, - 0x06, 0xdc, 0xdd, 0x08, 0x90, 0x07, 0x42, 0x90, 0x3c, 0x10, 0x97, 0xc0, 0xc9, 0x5d, 0x21, 0x9a, - 0x2f, 0x20, 0x7f, 0xcc, 0x85, 0x96, 0x98, 0xbf, 0xc5, 0x9f, 0x57, 0x81, 0x2c, 0x74, 0x2d, 0xe8, - 0xb8, 0xfa, 0xa7, 0xfd, 0x51, 0x7c, 0x97, 0xa7, 0x7d, 0x17, 0x66, 0xe4, 0x24, 0x18, 0x33, 0x76, - 0xf4, 0x70, 0x22, 0x49, 0xfb, 0xd9, 0xa0, 0x9b, 0x31, 0x13, 0x60, 0xd0, 0xdc, 0x40, 0x04, 0xf3, - 0x5c, 0x71, 0x3e, 0xe0, 0x3b, 0x60, 0xb8, 0x86, 0x29, 0x52, 0x11, 0x45, 0xec, 0x3e, 0x1c, 0x9d, - 0xbf, 0x90, 0x88, 0xd5, 0xb9, 0xc3, 0x17, 0xf3, 0xd2, 0xef, 0x81, 0xc1, 0xf7, 0xc0, 0xa8, 0xa6, - 0x6b, 0x54, 0xe6, 0x6d, 0xdb, 0x20, 0xc3, 0xbe, 0x9e, 0x08, 0xbb, 0xac, 0x6b, 0x54, 0x43, 0x55, - 0xed, 0xdb, 0x8c, 0x14, 0x66, 0xcd, 0x9c, 0xfd, 0x7a, 0x24, 0x12, 0xb0, 0x91, 0x9d, 0xe6, 0x0e, - 0xd6, 0xc0, 0x84, 0x43, 0xd6, 0x90, 0x0d, 0x64, 0x6a, 0x7a, 0xc5, 0x55, 0x38, 0xc4, 0x14, 0xbe, - 0x19, 0xaf, 0x4f, 0xb4, 0x01, 0x56, 0x9c, 0xf5, 0x3e, 0x35, 0xd0, 0x0c, 0x8f, 0x93, 0xf9, 0x7f, - 0x9c, 0x02, 0x83, 0x6c, 0x93, 0xe0, 0xcf, 0x53, 0x60, 0x22, 0x8a, 0x1b, 0x85, 0xd7, 0x92, 0x57, - 0xd4, 0x20, 0x6b, 0x9b, 0x59, 0xe8, 0x01, 0xc1, 0xc9, 0x16, 0xf1, 0x07, 0xc2, 0x77, 0x3e, 0xff, - 0xeb, 0x8f, 0x53, 0xdf, 0x15, 0xd6, 0x8a, 0xf0, 0x5a, 0x67, 0xee, 0xde, 0xcb, 0x4c, 0x4e, 0xc0, - 0x16, 0x9e, 0xf8, 0x72, 0xf5, 0x29, 0xbc, 0xdc, 0x15, 0x02, 0xcf, 0xd6, 0xa7, 0xf0, 0x73, 0x81, - 0x77, 0xf5, 0xc1, 0xf2, 0x0c, 0xaf, 0x26, 0xf7, 0x33, 0xc0, 0x01, 0x67, 0xae, 0x75, 0x0f, 0xc0, - 0xe3, 0x74, 0x91, 0x85, 0xe9, 0x35, 0x38, 0x97, 0xc0, 0x43, 0x87, 0x1d, 0x86, 0xef, 0xa7, 0x40, - 0xba, 0x0d, 0xe5, 0x4b, 0xe0, 0xed, 0x2e, 0x2d, 0x8b, 0x64, 0x97, 0x33, 0x77, 0xf6, 0x08, 0x8d, - 0x3b, 0x7d, 0x93, 0x39, 0x9d, 0x2c, 0x31, 0xb8, 0x90, 0x0d, 0x28, 0x7b, 0xc4, 0x2d, 0xfc, 0x9f, - 0x00, 0x8e, 0x46, 0x33, 0xc8, 0x04, 0xde, 0xea, 0xda, 0xe8, 0x56, 0xaa, 0x3a, 0x73, 0x7b, 0x6f, - 0xc0, 0x78, 0x00, 0x6e, 0xb0, 0x00, 0x2c, 0xc0, 0xab, 0x5d, 0x04, 0xc0, 0x30, 0x7d, 0xfe, 0xff, - 0xdb, 0xe5, 0xcc, 0x22, 0x29, 0x4a, 0xb8, 0x14, 0xdf, 0xea, 0xdd, 0x18, 0xd9, 0xcc, 0x8d, 0x9e, - 0x71, 0xb8, 0xe3, 0x0b, 0xcc, 0xf1, 0x37, 0xe1, 0xc5, 0x18, 0xff, 0xce, 0xf3, 0xb8, 0xed, 0x00, - 0x1b, 0x10, 0xe1, 0xb2, 0xff, 0x09, 0xda, 0x95, 0xcb, 0x11, 0x24, 0x6c, 0x57, 0x2e, 0x47, 0xd1, - 0xa3, 0xdd, 0xb9, 0x1c, 0x68, 0xcd, 0xe0, 0x6f, 0x05, 0xce, 0x55, 0x04, 0x98, 0x51, 0x78, 0x25, - 0xbe, 0x89, 0x51, 0x84, 0x6b, 0xe6, 0x6a, 0xd7, 0xeb, 0xb9, 0x6b, 0x6f, 0x30, 0xd7, 0xe6, 0xe1, - 0x6c, 0x67, 0xd7, 0x28, 0x07, 0x70, 0xfe, 0x4d, 0x07, 0x7f, 0x92, 0xe2, 0x2d, 0xcf, 0xee, 0x54, - 0x27, 0xbc, 0x17, 0xdf, 0xc4, 0x58, 0x14, 0x6b, 0x66, 0x79, 0xef, 0x00, 0x79, 0x10, 0x6e, 0xb1, - 0x20, 0x5c, 0x87, 0xa5, 0xce, 0x41, 0xb0, 0x3c, 0xc4, 0x66, 0x4e, 0x5b, 0x0c, 0x53, 0x76, 0xa8, - 0x5b, 0xf8, 0xcf, 0x16, 0x6a, 0x36, 0xc8, 0x13, 0x12, 0x98, 0xe0, 0x6e, 0x6e, 0xc3, 0xff, 0x66, - 0x8a, 0xbd, 0x40, 0x70, 0xaf, 0x8b, 0xcc, 0xeb, 0xb7, 0xe0, 0xa5, 0xce, 0x5e, 0xbb, 0xcc, 0xaf, - 0x1c, 0xbe, 0xc0, 0x3e, 0x4e, 0xf1, 0xff, 0x59, 0xc6, 0x20, 0x48, 0xe1, 0x6a, 0x7c, 0xa3, 0xe3, - 0x73, 0xbc, 0x99, 0xfb, 0x7b, 0x8c, 0xca, 0xa3, 0x53, 0x61, 0xd1, 0x41, 0x6b, 0x73, 0xb0, 0xd0, - 0x39, 0x3e, 0xc1, 0x56, 0xe7, 0x5c, 0x9c, 0x05, 0x5e, 0x67, 0xf3, 0x4b, 0x01, 0x8c, 0xfa, 0xf8, - 0x4a, 0xf8, 0x7a, 0x82, 0xad, 0xf5, 0xf3, 0x9e, 0x99, 0x37, 0x92, 0x2f, 0xe4, 0xbe, 0xce, 0x32, - 0x5f, 0xcf, 0xc0, 0x5c, 0x8c, 0x4c, 0x70, 0x8c, 0xfc, 0x63, 0x2a, 0xf4, 0xde, 0x89, 0x26, 0x25, - 0x93, 0x1c, 0xfe, 0x58, 0x64, 0x6a, 0x92, 0xc3, 0x1f, 0x8f, 0x2f, 0x15, 0x9f, 0x39, 0x6d, 0xee, - 0xf7, 0x85, 0xb5, 0x58, 0x05, 0xc0, 0xb0, 0x81, 0x64, 0x4d, 0x97, 0x9b, 0x6c, 0x45, 0x68, 0xfb, - 0xaf, 0x75, 0x0b, 0xe2, 0xa5, 0xc4, 0xaf, 0x52, 0xe0, 0x74, 0x6c, 0x2e, 0x02, 0xde, 0xef, 0xb6, - 0x83, 0xdd, 0x95, 0x4e, 0xc9, 0x3c, 0xd8, 0x6b, 0x58, 0x1e, 0xef, 0x35, 0x16, 0xee, 0x55, 0x28, - 0x25, 0x6e, 0x97, 0x65, 0x13, 0x5b, 0xcd, 0x88, 0x15, 0x9e, 0x84, 0xc9, 0x8f, 0xa7, 0xf0, 0x87, - 0xfd, 0xe0, 0xd5, 0x38, 0x94, 0x05, 0x5c, 0xee, 0xa1, 0x1b, 0x8a, 0xe4, 0x6a, 0x32, 0x6f, 0xef, - 0x21, 0x22, 0x8f, 0xd4, 0xc7, 0x4e, 0x66, 0xfe, 0x46, 0x58, 0x7b, 0x08, 0xdf, 0x4d, 0x12, 0xad, - 0x20, 0x9f, 0x1b, 0x4c, 0xcf, 0xa8, 0xb0, 0x7d, 0xbd, 0x27, 0x70, 0x37, 0x6d, 0xa3, 0x90, 0x7f, - 0x9d, 0x0a, 0x35, 0xf7, 0xbe, 0xda, 0x50, 0xea, 0x85, 0x36, 0x74, 0xc3, 0xbe, 0xd8, 0x1b, 0x48, - 0x77, 0x35, 0xc0, 0x0b, 0x46, 0x2f, 0x35, 0x20, 0x1a, 0xc4, 0xab, 0x01, 0xff, 0x12, 0x38, 0x13, - 0x14, 0x45, 0x78, 0xc1, 0x04, 0x94, 0xeb, 0x2e, 0xa4, 0x5a, 0x66, 0xa9, 0x57, 0x98, 0xe4, 0x0d, - 0x72, 0x1b, 0x7e, 0x0e, 0xfe, 0x47, 0x08, 0xfd, 0x18, 0x2b, 0xc8, 0xa0, 0xc1, 0x1b, 0xc9, 0x37, - 0x3a, 0x92, 0xc6, 0xcb, 0xdc, 0xec, 0x1d, 0x28, 0xb9, 0xd7, 0xbe, 0xe4, 0x28, 0x3c, 0xf1, 0x58, - 0xc4, 0xa7, 0xf0, 0x4f, 0xee, 0xb3, 0x20, 0x50, 0x42, 0x93, 0x3c, 0x0b, 0xa2, 0x88, 0xc2, 0xcc, - 0xd5, 0xae, 0xd7, 0x73, 0xd7, 0x96, 0x98, 0x6b, 0xd7, 0xe0, 0x95, 0xa4, 0x45, 0x3a, 0x78, 0x0e, - 0x8a, 0xef, 0x7c, 0xf2, 0x62, 0x5a, 0xf8, 0xf4, 0xc5, 0xb4, 0xf0, 0x97, 0x17, 0xd3, 0xc2, 0xb3, - 0x97, 0xd3, 0x7d, 0x9f, 0xbe, 0x9c, 0xee, 0xfb, 0xfd, 0xcb, 0xe9, 0xbe, 0xb5, 0xcb, 0x15, 0x8d, - 0x6e, 0x6c, 0xaf, 0xe7, 0x15, 0xa3, 0xc6, 0x7f, 0xb4, 0xe8, 0x53, 0x75, 0xde, 0x53, 0x55, 0xbf, - 0x50, 0x78, 0x1c, 0x7a, 0x86, 0x34, 0x4c, 0x4c, 0xd6, 0x87, 0xd8, 0x6f, 0x39, 0x5e, 0xfb, 0x7f, - 0x00, 0x00, 0x00, 0xff, 0xff, 0x10, 0xc5, 0x56, 0xdf, 0x54, 0x2a, 0x00, 0x00, + // 2676 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x5a, 0x4b, 0x6c, 0xdc, 0xc6, + 0xf9, 0x17, 0xf5, 0xf2, 0x6a, 0x64, 0x29, 0xc9, 0x58, 0xb6, 0xd7, 0x2b, 0x59, 0x2b, 0xd3, 0xf1, + 0xff, 0x2f, 0xbf, 0x76, 0x25, 0x05, 0x6e, 0x62, 0x27, 0x7e, 0x68, 0x57, 0x96, 0xbd, 0xf0, 0x4b, + 0xa1, 0x64, 0xa7, 0x50, 0xea, 0xd2, 0x14, 0x39, 0x59, 0xb1, 0xe2, 0x92, 0x14, 0x67, 0xb4, 0xf6, + 0xd6, 0xf5, 0x21, 0x2d, 0x50, 0xb8, 0x3d, 0x14, 0x2e, 0x8a, 0xde, 0x83, 0x02, 0x05, 0x7a, 0xe8, + 0xa9, 0x08, 0x5a, 0xf4, 0x96, 0x63, 0x6e, 0x4d, 0x93, 0x4b, 0xd1, 0xa2, 0x6e, 0x61, 0xf7, 0xd0, + 0x16, 0x28, 0x50, 0xa4, 0xbd, 0x16, 0x28, 0x38, 0x33, 0xe4, 0x92, 0x5c, 0xae, 0x96, 0xdc, 0xd5, + 0xa1, 0x37, 0x71, 0xe6, 0x9b, 0xdf, 0xf7, 0x98, 0x6f, 0xbe, 0xf9, 0xe6, 0xb7, 0x02, 0x45, 0xdd, + 0x24, 0xc8, 0x51, 0x37, 0x15, 0xdd, 0x94, 0x31, 0x52, 0x77, 0x1c, 0x9d, 0x34, 0x8a, 0xaa, 0x5a, + 0x2f, 0xda, 0x8e, 0x55, 0xd7, 0x35, 0xe4, 0x14, 0xeb, 0xf3, 0xc5, 0xed, 0x1d, 0xe4, 0x34, 0x0a, + 0xb6, 0x63, 0x11, 0x0b, 0x1e, 0x8f, 0x59, 0x50, 0x50, 0xd5, 0x7a, 0xc1, 0x5b, 0x50, 0xa8, 0xcf, + 0xe7, 0xa6, 0xaa, 0x96, 0x55, 0x35, 0x50, 0x51, 0xb1, 0xf5, 0xa2, 0x62, 0x9a, 0x16, 0x51, 0x88, + 0x6e, 0x99, 0x98, 0x41, 0xe4, 0x26, 0xaa, 0x56, 0xd5, 0xa2, 0x7f, 0x16, 0xdd, 0xbf, 0xf8, 0x68, + 0x9e, 0xaf, 0xa1, 0x5f, 0x1b, 0x3b, 0x1f, 0x14, 0x89, 0x5e, 0x43, 0x98, 0x28, 0x35, 0x9b, 0x0b, + 0x2c, 0x24, 0x31, 0xd5, 0xb7, 0x82, 0xad, 0x99, 0x6b, 0xb7, 0xa6, 0x3e, 0x5f, 0xc4, 0x9b, 0x8a, + 0x83, 0x34, 0x59, 0xb5, 0x4c, 0xbc, 0x53, 0xf3, 0x57, 0x9c, 0xd8, 0x65, 0xc5, 0x43, 0xdd, 0x41, + 0x5c, 0x6c, 0x8a, 0x20, 0x53, 0x43, 0x4e, 0x4d, 0x37, 0x49, 0x51, 0x75, 0x1a, 0x36, 0xb1, 0x8a, + 0x5b, 0xa8, 0xe1, 0x79, 0x78, 0x44, 0xb5, 0x70, 0xcd, 0xc2, 0x32, 0x73, 0x92, 0x7d, 0xf0, 0xa9, + 0xd7, 0xd9, 0x57, 0x11, 0x13, 0x65, 0x4b, 0x37, 0xab, 0xc5, 0xfa, 0xfc, 0x06, 0x22, 0xca, 0xbc, + 0xf7, 0xcd, 0xa4, 0xc4, 0xfb, 0x60, 0xf2, 0x5d, 0x37, 0xe8, 0x65, 0x6e, 0xdc, 0x35, 0x64, 0x22, + 0xac, 0x63, 0x09, 0x6d, 0xef, 0x20, 0x4c, 0xe0, 0x51, 0x90, 0x61, 0x16, 0xea, 0x5a, 0x56, 0x98, + 0x11, 0x66, 0x47, 0x4a, 0xfd, 0x59, 0x41, 0xda, 0x47, 0xc7, 0x2a, 0x1a, 0xcc, 0x83, 0x51, 0xcf, + 0x2b, 0x57, 0xa2, 0xdf, 0x95, 0x90, 0x80, 0x37, 0x54, 0xd1, 0xc4, 0xc7, 0x60, 0x2a, 0x1e, 0x1e, + 0xdb, 0x96, 0x89, 0x11, 0x7c, 0x1f, 0x8c, 0x55, 0xd9, 0x90, 0x8c, 0x89, 0x42, 0x10, 0x55, 0x32, + 0xba, 0x30, 0x57, 0x68, 0xb7, 0xf9, 0xf5, 0xf9, 0x42, 0x04, 0x6b, 0xd5, 0x5d, 0x57, 0x1a, 0xfc, + 0xf4, 0x79, 0xbe, 0x4f, 0xda, 0x5f, 0x0d, 0x8c, 0x89, 0xdf, 0x02, 0xb9, 0x90, 0xf2, 0xb2, 0x0b, + 0xe7, 0xbb, 0x76, 0x1d, 0x0c, 0xd9, 0x9b, 0x0a, 0x66, 0x2a, 0xc7, 0x17, 0x16, 0x0a, 0x09, 0xf2, + 0xcd, 0xd7, 0xbd, 0xe2, 0xae, 0x94, 0x18, 0x00, 0x9c, 0x00, 0x43, 0x86, 0x5e, 0xd3, 0x09, 0xf5, + 0x7f, 0x48, 0x62, 0x1f, 0xa2, 0x12, 0x89, 0xac, 0xa7, 0x9d, 0x7b, 0x5e, 0x02, 0xc3, 0x54, 0x17, + 0xce, 0x0a, 0x33, 0x03, 0xb3, 0xa3, 0x0b, 0xa7, 0x92, 0xe9, 0x77, 0xa7, 0x25, 0xbe, 0x52, 0x3c, + 0x09, 0xfe, 0xbf, 0x55, 0xc5, 0x2a, 0x51, 0x1c, 0xb2, 0xe2, 0x58, 0xb6, 0x85, 0x15, 0xc3, 0xf3, + 0x56, 0x7c, 0x2a, 0x80, 0xd9, 0xce, 0xb2, 0xdc, 0xb6, 0xaf, 0x81, 0x11, 0xdb, 0x1b, 0xe4, 0x3b, + 0x72, 0x29, 0x55, 0x78, 0x16, 0x35, 0x4d, 0x77, 0x0f, 0x62, 0x13, 0xba, 0x09, 0x28, 0xce, 0x82, + 0xff, 0x8b, 0xb3, 0xc4, 0xb2, 0x5b, 0x8c, 0xfe, 0xae, 0x10, 0xef, 0x60, 0x48, 0xd4, 0xcf, 0xa4, + 0x16, 0x9b, 0x2f, 0xa6, 0xb2, 0x59, 0x42, 0x35, 0xab, 0xae, 0x18, 0xb1, 0x26, 0x3f, 0x1d, 0x04, + 0x43, 0x54, 0x37, 0x3c, 0x12, 0x3d, 0x10, 0xcd, 0xc3, 0x30, 0x09, 0x46, 0x54, 0x43, 0x47, 0x26, + 0x69, 0x1e, 0x85, 0x0c, 0x1b, 0xa8, 0x68, 0xf0, 0x00, 0x18, 0x22, 0x96, 0x2d, 0xdf, 0xce, 0x0e, + 0xcc, 0x08, 0xb3, 0x63, 0xd2, 0x20, 0xb1, 0xec, 0xdb, 0xf0, 0x14, 0x80, 0x35, 0xdd, 0x94, 0x6d, + 0xeb, 0xa1, 0x7b, 0x7e, 0x4c, 0x99, 0x49, 0x0c, 0xce, 0x08, 0xb3, 0x03, 0xd2, 0x78, 0x4d, 0x37, + 0x57, 0xdc, 0x89, 0x8a, 0xb9, 0xe6, 0xca, 0xce, 0x81, 0x89, 0xba, 0x62, 0xe8, 0x9a, 0x42, 0x2c, + 0x07, 0xf3, 0x25, 0xaa, 0x62, 0x67, 0x87, 0x28, 0x1e, 0x6c, 0xce, 0xd1, 0x45, 0x65, 0xc5, 0x86, + 0xa7, 0xc0, 0x6b, 0xfe, 0xa8, 0x8c, 0x11, 0xa1, 0xe2, 0xc3, 0x54, 0xfc, 0x15, 0x7f, 0x62, 0x15, + 0x11, 0x57, 0x76, 0x0a, 0x8c, 0x28, 0x86, 0x61, 0x3d, 0x34, 0x74, 0x4c, 0xb2, 0xfb, 0x66, 0x06, + 0x66, 0x47, 0xa4, 0xe6, 0x00, 0xcc, 0x81, 0x8c, 0x86, 0xcc, 0x06, 0x9d, 0xcc, 0xd0, 0x49, 0xff, + 0xbb, 0x79, 0x8c, 0x46, 0x7a, 0x3d, 0x46, 0xef, 0x81, 0x4c, 0x0d, 0x11, 0x45, 0x53, 0x88, 0x92, + 0x05, 0x74, 0x03, 0xcf, 0xa5, 0x02, 0xbb, 0xc5, 0x17, 0xf3, 0x5a, 0xe0, 0x83, 0xb9, 0x1b, 0xe3, + 0x86, 0xd9, 0x2d, 0x7c, 0x28, 0x3b, 0x3a, 0x23, 0xcc, 0x0e, 0x4a, 0x99, 0x1a, 0x4d, 0xfe, 0x2d, + 0x04, 0x0b, 0xe0, 0x00, 0x75, 0x54, 0xd6, 0x4d, 0x45, 0x25, 0x7a, 0x1d, 0xc9, 0x75, 0x37, 0x83, + 0xf6, 0xcf, 0x08, 0xb3, 0x19, 0xe9, 0x35, 0x3a, 0x55, 0xe1, 0x33, 0xf7, 0xdc, 0x54, 0xf8, 0xb9, + 0x00, 0x8e, 0xd1, 0x9c, 0xbc, 0xe7, 0x85, 0x30, 0x90, 0xf4, 0x4e, 0xc2, 0xba, 0x79, 0x11, 0xbc, + 0xea, 0x79, 0x20, 0x2b, 0x9a, 0xe6, 0x20, 0x8c, 0x59, 0xc6, 0x94, 0xe0, 0x97, 0xcf, 0xf3, 0xe3, + 0x0d, 0xa5, 0x66, 0x5c, 0x10, 0xf9, 0x84, 0x28, 0xbd, 0xe2, 0xc9, 0x2e, 0xb2, 0x91, 0x68, 0xd9, + 0x1d, 0x88, 0x96, 0xdd, 0x0b, 0x99, 0xa7, 0x1f, 0xe5, 0xfb, 0xfe, 0xfa, 0x51, 0xbe, 0x4f, 0xbc, + 0x03, 0xc4, 0xdd, 0xac, 0xe5, 0x87, 0xe7, 0x24, 0x78, 0xd5, 0x07, 0xf4, 0xec, 0x61, 0xd9, 0xfd, + 0x8a, 0x1a, 0x90, 0x77, 0xad, 0x69, 0xf5, 0x7f, 0x25, 0x60, 0x5d, 0x72, 0xff, 0x5b, 0xf4, 0xed, + 0xe2, 0x7f, 0xc4, 0x86, 0x9e, 0xfc, 0x0f, 0x5b, 0xdb, 0xf4, 0xbf, 0x65, 0x3f, 0xb8, 0xff, 0x91, + 0xd8, 0x8b, 0x93, 0xe0, 0x08, 0x05, 0x5c, 0xdb, 0x74, 0x2c, 0x42, 0x0c, 0x44, 0xaf, 0x1a, 0xaf, + 0x60, 0xfd, 0x56, 0xe0, 0x57, 0x4e, 0x64, 0x96, 0xab, 0xc9, 0x83, 0x51, 0x6c, 0x28, 0x78, 0x53, + 0xae, 0x21, 0x82, 0x1c, 0xaa, 0x61, 0x40, 0x02, 0x74, 0xe8, 0x96, 0x3b, 0x02, 0x17, 0xc0, 0xc1, + 0x80, 0x80, 0x4c, 0xb3, 0x4f, 0x31, 0x55, 0x44, 0x83, 0x33, 0x20, 0x1d, 0x68, 0x8a, 0x2e, 0x7a, + 0x53, 0xf0, 0xeb, 0x20, 0x6b, 0xa2, 0x47, 0x44, 0x76, 0x90, 0x6d, 0x20, 0x53, 0xc7, 0x9b, 0xb2, + 0xaa, 0x98, 0x9a, 0xeb, 0x2c, 0xa2, 0x91, 0x19, 0x5d, 0xc8, 0x15, 0x58, 0xc7, 0x53, 0xf0, 0x3a, + 0x9e, 0xc2, 0x9a, 0xd7, 0xf1, 0x94, 0x32, 0xee, 0x59, 0x79, 0xf6, 0xa7, 0xbc, 0x20, 0x1d, 0x72, + 0x51, 0x24, 0x0f, 0xa4, 0xec, 0x61, 0x88, 0x67, 0xc0, 0x29, 0xea, 0x92, 0x84, 0xaa, 0x3a, 0x26, + 0xc8, 0x41, 0x5a, 0xb3, 0x62, 0x3e, 0x54, 0x1c, 0x6d, 0x09, 0x99, 0x56, 0xcd, 0x2f, 0xd9, 0x57, + 0xc1, 0xe9, 0x44, 0xd2, 0x3c, 0x22, 0x87, 0xc0, 0xb0, 0x46, 0x47, 0xe8, 0x2d, 0x38, 0x22, 0xf1, + 0x2f, 0x71, 0x9a, 0xf7, 0x0d, 0xac, 0x1a, 0x23, 0x8d, 0x16, 0xdf, 0xca, 0x92, 0xaf, 0xe6, 0x43, + 0x01, 0x1c, 0x6d, 0x23, 0xc0, 0x91, 0x1f, 0x80, 0x71, 0x3b, 0x38, 0xe7, 0xdd, 0xb3, 0xc9, 0x0a, + 0x54, 0x08, 0x96, 0x17, 0x94, 0x08, 0x9e, 0x68, 0x82, 0xb1, 0x90, 0x18, 0x9c, 0x02, 0x3c, 0xc1, + 0x97, 0x5a, 0x73, 0x7e, 0x09, 0x4e, 0x03, 0xe0, 0x5d, 0x28, 0x95, 0x25, 0xba, 0xa1, 0x83, 0x52, + 0x60, 0xa4, 0x63, 0x52, 0x8b, 0xdb, 0xa0, 0x48, 0x5d, 0x5e, 0x34, 0x8c, 0x15, 0x45, 0x77, 0xf0, + 0x3d, 0xc5, 0x28, 0x5b, 0xa6, 0x9b, 0x97, 0xa5, 0xf0, 0x05, 0x59, 0x59, 0xda, 0xab, 0xf6, 0xed, + 0xa7, 0x02, 0x98, 0x4b, 0xae, 0x93, 0x47, 0x7e, 0x1b, 0xbc, 0x66, 0x2b, 0xba, 0xe3, 0xd6, 0x51, + 0xb7, 0xe7, 0xa5, 0x07, 0x8a, 0x07, 0x7f, 0x39, 0x59, 0xf0, 0x15, 0xdd, 0x69, 0x2a, 0xf2, 0x0f, + 0xac, 0xd9, 0x4c, 0xa5, 0x71, 0x3b, 0x24, 0x22, 0xfe, 0x5b, 0x00, 0xc7, 0x3a, 0xae, 0x82, 0xcb, + 0xed, 0x4e, 0x79, 0x69, 0xf2, 0xcb, 0xe7, 0xf9, 0xc3, 0xac, 0xea, 0x44, 0x25, 0x62, 0xca, 0xef, + 0x72, 0xdb, 0xea, 0x15, 0xc0, 0x89, 0x4a, 0xc4, 0x94, 0xb1, 0xcb, 0x60, 0xbf, 0x2f, 0xb5, 0x85, + 0x1a, 0xfc, 0xb4, 0x4e, 0x15, 0x9a, 0x1d, 0x7f, 0x81, 0x75, 0xfc, 0x85, 0x95, 0x9d, 0x0d, 0x43, + 0x57, 0x6f, 0xa0, 0x86, 0xe4, 0x6f, 0xd8, 0x0d, 0xd4, 0x10, 0x27, 0x00, 0x64, 0x87, 0x40, 0x71, + 0x94, 0xe6, 0x11, 0x7c, 0x00, 0x0e, 0x84, 0x46, 0xf9, 0xb6, 0x54, 0xc0, 0xb0, 0x4d, 0x47, 0x78, + 0x77, 0x74, 0x3a, 0xe1, 0x5e, 0xb8, 0x4b, 0xf8, 0x09, 0xe0, 0x00, 0xa2, 0xc1, 0x4b, 0x42, 0x28, + 0x03, 0xee, 0xd8, 0x04, 0x69, 0x15, 0xd3, 0x2f, 0xb4, 0x7b, 0xf6, 0x86, 0xd8, 0xe6, 0x25, 0xa5, + 0x93, 0x36, 0xbf, 0xb1, 0x3e, 0x1a, 0x6c, 0x94, 0x22, 0xdb, 0x89, 0xbc, 0x4a, 0x33, 0x19, 0xe8, + 0x98, 0xc2, 0xfb, 0x8b, 0xb0, 0xf8, 0x00, 0x4c, 0x87, 0x54, 0xee, 0xbd, 0x53, 0x3f, 0xdc, 0x07, + 0x66, 0xda, 0xa8, 0xf0, 0xff, 0x8a, 0x6d, 0x13, 0x84, 0xe4, 0x6d, 0x42, 0x34, 0xbf, 0xfa, 0x53, + 0xe6, 0x17, 0xcc, 0x82, 0x21, 0xda, 0x68, 0xd2, 0xcc, 0x1c, 0xa0, 0x1e, 0xb2, 0x01, 0x78, 0x1e, + 0x0c, 0x3a, 0xee, 0x05, 0x33, 0x48, 0xad, 0x39, 0xe1, 0x66, 0xc7, 0xef, 0x9f, 0xe7, 0x27, 0xd9, + 0x93, 0x13, 0x6b, 0x5b, 0x05, 0xdd, 0x2a, 0xd6, 0x14, 0xb2, 0x59, 0xb8, 0x89, 0xaa, 0x8a, 0xda, + 0x58, 0x42, 0x6a, 0x56, 0x90, 0xe8, 0x12, 0x78, 0x02, 0x8c, 0xfb, 0x56, 0x31, 0xf4, 0x21, 0x7a, + 0xb9, 0x8d, 0x79, 0xa3, 0xb4, 0x81, 0x85, 0xf7, 0x41, 0xd6, 0x17, 0x53, 0xad, 0x5a, 0x4d, 0xc7, + 0x58, 0xb7, 0x4c, 0x99, 0x6a, 0x1d, 0xa6, 0x5a, 0x8f, 0x27, 0xd0, 0x2a, 0x1d, 0xf2, 0x40, 0xca, + 0x3e, 0x86, 0xe4, 0x5a, 0x71, 0x1f, 0x64, 0xfd, 0xd0, 0x46, 0xe1, 0xf7, 0xa5, 0x80, 0xf7, 0x40, + 0x22, 0xf0, 0x37, 0xc0, 0xa8, 0x86, 0xb0, 0xea, 0xe8, 0xb6, 0xfb, 0x0c, 0xca, 0x66, 0x68, 0xe4, + 0x8f, 0x17, 0xf8, 0x03, 0xdd, 0x7b, 0x82, 0xf3, 0x27, 0x79, 0x61, 0xa9, 0x29, 0xca, 0x4f, 0x5a, + 0x70, 0x35, 0xbc, 0x0f, 0x8e, 0xf8, 0xb6, 0x5a, 0x36, 0x72, 0x68, 0x43, 0xef, 0xe5, 0xc3, 0x08, + 0x35, 0xf6, 0xd8, 0xe7, 0x1f, 0x9f, 0x3d, 0xca, 0xd1, 0xfd, 0xfc, 0xe1, 0x79, 0xb0, 0x4a, 0x1c, + 0xdd, 0xac, 0x4a, 0x87, 0x3d, 0x8c, 0x3b, 0x1c, 0xc2, 0x4b, 0x93, 0x43, 0x60, 0xf8, 0x1b, 0x8a, + 0x6e, 0x20, 0x8d, 0x76, 0xdd, 0x19, 0x89, 0x7f, 0xc1, 0x0b, 0x60, 0xd8, 0x7d, 0x93, 0xef, 0x60, + 0xda, 0x33, 0x8f, 0x2f, 0x88, 0xed, 0xcc, 0x2f, 0x59, 0xa6, 0xb6, 0x4a, 0x25, 0x25, 0xbe, 0x02, + 0xae, 0x01, 0x3f, 0x1b, 0x65, 0x62, 0x6d, 0x21, 0x93, 0x75, 0xd4, 0x23, 0xa5, 0xd3, 0x3c, 0xaa, + 0x07, 0x5b, 0xa3, 0x5a, 0x31, 0xc9, 0xe7, 0x1f, 0x9f, 0x05, 0x5c, 0x49, 0xc5, 0x24, 0xf4, 0xc6, + 0xa5, 0x18, 0x6b, 0x14, 0xc2, 0x4d, 0x1d, 0x1f, 0x95, 0xa5, 0xce, 0x18, 0x4b, 0x1d, 0x6f, 0x94, + 0xa5, 0xce, 0x57, 0xc0, 0x61, 0x7e, 0xb8, 0x11, 0x96, 0xd5, 0x1d, 0xc7, 0x71, 0xdf, 0x64, 0xc8, + 0xb6, 0xd4, 0xcd, 0xec, 0x38, 0xf5, 0xf0, 0xa0, 0x3f, 0x5d, 0x66, 0xb3, 0x57, 0xdd, 0x49, 0xf7, + 0x8d, 0x9c, 0x6f, 0x7b, 0xec, 0x79, 0x75, 0x41, 0x00, 0x34, 0x0b, 0x07, 0xbf, 0xd5, 0xae, 0x26, + 0xaa, 0xa4, 0x9d, 0x4e, 0xbb, 0x14, 0x00, 0x16, 0xb7, 0xf9, 0xbd, 0x1b, 0x26, 0x0f, 0x7c, 0xd9, + 0xeb, 0x0a, 0x5e, 0xb3, 0xf8, 0x97, 0xd7, 0x7c, 0xf6, 0x58, 0x2d, 0x44, 0x05, 0xcc, 0xa7, 0x50, + 0xc9, 0xc3, 0x71, 0x06, 0xc0, 0xe6, 0x29, 0xe5, 0xf5, 0xd0, 0xab, 0xb0, 0xfe, 0x25, 0xc9, 0x1a, + 0x04, 0x8d, 0xbe, 0x1d, 0x4e, 0xc7, 0xbf, 0x46, 0xc2, 0xc7, 0xe7, 0x7f, 0xe3, 0x15, 0x25, 0x56, + 0xc1, 0x99, 0x64, 0xd6, 0xf2, 0x60, 0xbc, 0xc9, 0x8b, 0xa2, 0x90, 0xbc, 0x7e, 0xd0, 0x05, 0xa2, + 0xc8, 0xef, 0x82, 0x92, 0x61, 0xa9, 0x5b, 0xf8, 0xae, 0x49, 0x74, 0xe3, 0x36, 0x7a, 0xc4, 0xb2, + 0xd2, 0xbb, 0xd5, 0xd7, 0xf9, 0xb3, 0x2b, 0x5e, 0x86, 0x5b, 0x70, 0x0e, 0x1c, 0xde, 0xa0, 0xf3, + 0xf2, 0x8e, 0x2b, 0x20, 0xd3, 0x87, 0x01, 0xcb, 0x7c, 0x81, 0x36, 0x9c, 0x13, 0x1b, 0x31, 0xcb, + 0xc5, 0x45, 0xfe, 0x48, 0x2a, 0xfb, 0xbe, 0x2f, 0x3b, 0x56, 0xad, 0xcc, 0xb9, 0x0b, 0x6f, 0x37, + 0x42, 0xfc, 0x86, 0x10, 0xe6, 0x37, 0xc4, 0x65, 0x70, 0x7c, 0x57, 0x88, 0xe6, 0x0b, 0x28, 0x18, + 0x73, 0xa1, 0x25, 0xe6, 0xef, 0xf0, 0xe7, 0x55, 0x28, 0x0b, 0x3d, 0x0b, 0x3a, 0xae, 0xfe, 0xc9, + 0x40, 0x1c, 0xe5, 0xe7, 0x6b, 0xdf, 0x85, 0xbc, 0x39, 0x0e, 0xc6, 0xac, 0x87, 0x66, 0x34, 0x91, + 0xa4, 0xfd, 0x74, 0xd0, 0xcb, 0x98, 0x09, 0x8f, 0xeb, 0x60, 0xb9, 0x12, 0xc3, 0x5b, 0x0c, 0xee, + 0x25, 0x6f, 0xf1, 0x01, 0x18, 0xd5, 0x4d, 0x9d, 0xc8, 0xbc, 0x6d, 0x1b, 0xa2, 0xd8, 0x57, 0x53, + 0x61, 0x57, 0x4c, 0x9d, 0xe8, 0x8a, 0xa1, 0x7f, 0x93, 0xf2, 0xe2, 0xb4, 0x99, 0x73, 0x5f, 0x8f, + 0x58, 0x02, 0x2e, 0x32, 0x6b, 0xee, 0x60, 0x0d, 0x4c, 0x30, 0x3e, 0x09, 0x6f, 0x2a, 0xb6, 0x6e, + 0x56, 0x3d, 0x85, 0xc3, 0x54, 0xe1, 0xdb, 0xc9, 0xfa, 0x44, 0x17, 0x60, 0x95, 0xad, 0x0f, 0xa8, + 0x81, 0x76, 0x74, 0x1c, 0x2f, 0xfc, 0xed, 0x04, 0x18, 0xa2, 0x9b, 0x04, 0x7f, 0xd6, 0x0f, 0x26, + 0xe2, 0xe8, 0x61, 0x78, 0x25, 0x7d, 0x45, 0x0d, 0x13, 0xd7, 0xb9, 0xc5, 0x1e, 0x10, 0x58, 0xb6, + 0x88, 0xdf, 0x17, 0xbe, 0xfd, 0xc5, 0x5f, 0x7e, 0xd4, 0xff, 0x1d, 0x61, 0xbd, 0x04, 0xaf, 0x74, + 0xfe, 0xf9, 0xc2, 0xcf, 0x4c, 0xce, 0x41, 0x17, 0x1f, 0x07, 0x72, 0xf5, 0x09, 0xbc, 0xd8, 0x15, + 0x02, 0xcf, 0xd6, 0x27, 0xf0, 0x0b, 0x81, 0x77, 0xf5, 0xe1, 0xf2, 0x0c, 0x2f, 0xa7, 0xf7, 0x33, + 0x44, 0x83, 0xe7, 0xae, 0x74, 0x0f, 0xc0, 0xe3, 0x74, 0x9e, 0x86, 0xe9, 0x0d, 0x38, 0x9f, 0xc2, + 0x43, 0x46, 0x60, 0xc3, 0x0f, 0xfb, 0x41, 0xb6, 0x0d, 0x2b, 0x8d, 0xe1, 0xcd, 0x2e, 0x2d, 0x8b, + 0x25, 0xc0, 0x73, 0xb7, 0xf6, 0x08, 0x8d, 0x3b, 0x7d, 0x9d, 0x3a, 0x9d, 0x2e, 0x31, 0xb8, 0x90, + 0x0b, 0x28, 0xfb, 0xdc, 0x32, 0xfc, 0x8f, 0x00, 0x0e, 0xc7, 0x93, 0xdc, 0x18, 0xde, 0xe8, 0xda, + 0xe8, 0x56, 0x36, 0x3d, 0x77, 0x73, 0x6f, 0xc0, 0x78, 0x00, 0xae, 0xd1, 0x00, 0x2c, 0xc2, 0xcb, + 0x5d, 0x04, 0xc0, 0xb2, 0x03, 0xfe, 0xff, 0xd3, 0xe3, 0xcc, 0x62, 0x29, 0x4a, 0xb8, 0x9c, 0xdc, + 0xea, 0xdd, 0x18, 0xd9, 0xdc, 0xb5, 0x9e, 0x71, 0xb8, 0xe3, 0x8b, 0xd4, 0xf1, 0xb7, 0xe1, 0xf9, + 0x04, 0xbf, 0x68, 0xfa, 0xf4, 0x7b, 0x88, 0x0d, 0x88, 0x71, 0x39, 0xf8, 0x04, 0xed, 0xca, 0xe5, + 0x18, 0x12, 0xb6, 0x2b, 0x97, 0xe3, 0xe8, 0xd1, 0xee, 0x5c, 0x0e, 0xb5, 0x66, 0xf0, 0x37, 0x02, + 0xe7, 0x2a, 0x42, 0xcc, 0x28, 0xbc, 0x94, 0xdc, 0xc4, 0x38, 0xc2, 0x35, 0x77, 0xb9, 0xeb, 0xf5, + 0xdc, 0xb5, 0xb7, 0xa8, 0x6b, 0x0b, 0x70, 0xae, 0xb3, 0x6b, 0x84, 0x03, 0xb0, 0x5f, 0x2a, 0xe1, + 0x8f, 0xfb, 0x79, 0xcb, 0xb3, 0x3b, 0xd5, 0x09, 0xef, 0x24, 0x37, 0x31, 0x11, 0xc5, 0x9a, 0x5b, + 0xd9, 0x3b, 0x40, 0x1e, 0x84, 0x1b, 0x34, 0x08, 0x57, 0x61, 0xb9, 0x73, 0x10, 0x1c, 0x1f, 0xb1, + 0x99, 0xd3, 0x0e, 0xc5, 0x94, 0x19, 0x75, 0x0b, 0xff, 0xde, 0x42, 0xcd, 0x86, 0x79, 0x42, 0x0c, + 0x53, 0xdc, 0xcd, 0x6d, 0xf8, 0xdf, 0x5c, 0xa9, 0x17, 0x08, 0xee, 0x75, 0x89, 0x7a, 0xfd, 0x0e, + 0xbc, 0xd0, 0xd9, 0x6b, 0x8f, 0xf9, 0x95, 0xa3, 0x17, 0xd8, 0x27, 0xfd, 0xfc, 0x67, 0xd5, 0x04, + 0x04, 0x29, 0x5c, 0x4b, 0x6e, 0x74, 0x72, 0x8e, 0x37, 0x77, 0x77, 0x8f, 0x51, 0x79, 0x74, 0xaa, + 0x34, 0x3a, 0xca, 0xfa, 0x3c, 0x2c, 0x76, 0x8e, 0x4f, 0xb8, 0xd5, 0x39, 0x93, 0x64, 0x81, 0xdf, + 0xd9, 0xfc, 0x42, 0x00, 0xa3, 0x01, 0xbe, 0x12, 0xbe, 0x99, 0x62, 0x6b, 0x83, 0xbc, 0x67, 0xee, + 0xad, 0xf4, 0x0b, 0xb9, 0xaf, 0x73, 0xd4, 0xd7, 0x53, 0x70, 0x36, 0x41, 0x26, 0x30, 0x23, 0xff, + 0xd0, 0x1f, 0x79, 0xef, 0xc4, 0x93, 0x92, 0x69, 0x0e, 0x7f, 0x22, 0x32, 0x35, 0xcd, 0xe1, 0x4f, + 0xc6, 0x97, 0x8a, 0xcf, 0x58, 0x9b, 0xfb, 0x3d, 0x61, 0x3d, 0x51, 0x01, 0xb0, 0x5c, 0x20, 0x59, + 0x37, 0xe5, 0x26, 0x5b, 0x11, 0xd9, 0xfe, 0x2b, 0xdd, 0x82, 0xf8, 0x29, 0xf1, 0xcb, 0x7e, 0x70, + 0x32, 0x31, 0x17, 0x01, 0xef, 0x76, 0xdb, 0xc1, 0xee, 0x4a, 0xa7, 0xe4, 0xee, 0xed, 0x35, 0x2c, + 0x8f, 0xf7, 0x3a, 0x0d, 0xf7, 0x1a, 0x94, 0x52, 0xb7, 0xcb, 0xb2, 0x8d, 0x9c, 0x66, 0xc4, 0x8a, + 0x8f, 0xa3, 0xe4, 0xc7, 0x13, 0xf8, 0x83, 0x01, 0xf0, 0x7a, 0x12, 0xca, 0x02, 0xae, 0xf4, 0xd0, + 0x0d, 0xc5, 0x72, 0x35, 0xb9, 0x77, 0xf7, 0x10, 0x91, 0x47, 0xea, 0x13, 0x96, 0x99, 0xbf, 0x16, + 0xd6, 0xef, 0xc3, 0xf7, 0xd3, 0x44, 0x2b, 0xcc, 0xe7, 0x86, 0xd3, 0x33, 0x2e, 0x6c, 0x5f, 0xed, + 0x09, 0xdc, 0x4b, 0xdb, 0x38, 0xe4, 0x5f, 0xf5, 0x47, 0x9a, 0xfb, 0x40, 0x6d, 0x28, 0xf7, 0x42, + 0x1b, 0x7a, 0x61, 0x5f, 0xea, 0x0d, 0xa4, 0xbb, 0x1a, 0xe0, 0x07, 0xa3, 0x97, 0x1a, 0x10, 0x0f, + 0xe2, 0xd7, 0x80, 0x7f, 0x08, 0x9c, 0x09, 0x8a, 0x23, 0xbc, 0x60, 0x0a, 0xca, 0x75, 0x17, 0x52, + 0x2d, 0xb7, 0xdc, 0x2b, 0x4c, 0xfa, 0x06, 0xb9, 0x0d, 0x3f, 0x07, 0xff, 0x25, 0x44, 0xfe, 0x5f, + 0x2c, 0xcc, 0xa0, 0xc1, 0x6b, 0xe9, 0x37, 0x3a, 0x96, 0xc6, 0xcb, 0x5d, 0xef, 0x1d, 0x28, 0xbd, + 0xd7, 0x81, 0xe4, 0x28, 0x3e, 0xf6, 0x59, 0xc4, 0x27, 0xf0, 0x8f, 0xde, 0xb3, 0x20, 0x54, 0x42, + 0xd3, 0x3c, 0x0b, 0xe2, 0x88, 0xc2, 0xdc, 0xe5, 0xae, 0xd7, 0x73, 0xd7, 0x96, 0xa9, 0x6b, 0x57, + 0xe0, 0xa5, 0xb4, 0x45, 0x3a, 0x7c, 0x0e, 0x4a, 0xef, 0x7d, 0xfa, 0x62, 0x5a, 0xf8, 0xec, 0xc5, + 0xb4, 0xf0, 0xe7, 0x17, 0xd3, 0xc2, 0xb3, 0x97, 0xd3, 0x7d, 0x9f, 0xbd, 0x9c, 0xee, 0xfb, 0xdd, + 0xcb, 0xe9, 0xbe, 0xf5, 0x8b, 0x55, 0x9d, 0x6c, 0xee, 0x6c, 0x14, 0x54, 0xab, 0xc6, 0xff, 0x6f, + 0x33, 0xa0, 0xea, 0xac, 0xaf, 0xaa, 0x7e, 0xae, 0xf8, 0x28, 0xf2, 0x0c, 0x69, 0xd8, 0x08, 0x6f, + 0x0c, 0xd3, 0xff, 0xe5, 0x78, 0xe3, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0xb4, 0xb1, 0x32, 0xd1, + 0x57, 0x2b, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -3177,6 +3218,16 @@ func (m *QueryConsumerChainsRequest) MarshalToSizedBuffer(dAtA []byte) (int, err _ = i var l int _ = l + if m.Limit != 0 { + i = encodeVarintQuery(dAtA, i, uint64(m.Limit)) + i-- + dAtA[i] = 0x10 + } + if m.Phase != 0 { + i = encodeVarintQuery(dAtA, i, uint64(m.Phase)) + i-- + dAtA[i] = 0x8 + } return len(dAtA) - i, nil } @@ -3361,11 +3412,26 @@ func (m *Chain) MarshalToSizedBuffer(dAtA []byte) (int, error) { dAtA[i] = 0 } i-- - dAtA[i] = 0x50 + dAtA[i] = 0x60 } if m.MinStake != 0 { i = encodeVarintQuery(dAtA, i, uint64(m.MinStake)) i-- + dAtA[i] = 0x58 + } + { + size, err := m.Metadata.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x52 + if m.Phase != 0 { + i = encodeVarintQuery(dAtA, i, uint64(m.Phase)) + i-- dAtA[i] = 0x48 } if len(m.Denylist) > 0 { @@ -3614,12 +3680,12 @@ func (m *QueryThrottleStateResponse) MarshalToSizedBuffer(dAtA []byte) (int, err _ = i var l int _ = l - n4, err4 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.NextReplenishCandidate, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.NextReplenishCandidate):]) - if err4 != nil { - return 0, err4 + n5, err5 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.NextReplenishCandidate, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.NextReplenishCandidate):]) + if err5 != nil { + return 0, err5 } - i -= n4 - i = encodeVarintQuery(dAtA, i, uint64(n4)) + i -= n5 + i = encodeVarintQuery(dAtA, i, uint64(n5)) i-- dAtA[i] = 0x1a if m.SlashMeterAllowance != 0 { @@ -4656,6 +4722,12 @@ func (m *QueryConsumerChainsRequest) Size() (n int) { } var l int _ = l + if m.Phase != 0 { + n += 1 + sovQuery(uint64(m.Phase)) + } + if m.Limit != 0 { + n += 1 + sovQuery(uint64(m.Limit)) + } return n } @@ -4756,6 +4828,11 @@ func (m *Chain) Size() (n int) { n += 1 + l + sovQuery(uint64(l)) } } + if m.Phase != 0 { + n += 1 + sovQuery(uint64(m.Phase)) + } + l = m.Metadata.Size() + n += 1 + l + sovQuery(uint64(l)) if m.MinStake != 0 { n += 1 + sovQuery(uint64(m.MinStake)) } @@ -5496,6 +5573,44 @@ func (m *QueryConsumerChainsRequest) Unmarshal(dAtA []byte) error { return fmt.Errorf("proto: QueryConsumerChainsRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Phase", wireType) + } + m.Phase = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Phase |= ConsumerPhase(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType) + } + m.Limit = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Limit |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } default: iNdEx = preIndex skippy, err := skipQuery(dAtA[iNdEx:]) @@ -6107,6 +6222,58 @@ func (m *Chain) Unmarshal(dAtA []byte) error { m.Denylist = append(m.Denylist, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex case 9: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Phase", wireType) + } + m.Phase = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Phase |= ConsumerPhase(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", 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.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 11: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field MinStake", wireType) } @@ -6125,7 +6292,7 @@ func (m *Chain) Unmarshal(dAtA []byte) error { break } } - case 10: + case 12: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field AllowInactiveVals", wireType) } diff --git a/x/ccv/provider/types/query.pb.gw.go b/x/ccv/provider/types/query.pb.gw.go index 73a7714e22..80e0b6025d 100644 --- a/x/ccv/provider/types/query.pb.gw.go +++ b/x/ccv/provider/types/query.pb.gw.go @@ -177,10 +177,21 @@ func local_request_Query_QueryConsumerGenesis_1(ctx context.Context, marshaler r } +var ( + filter_Query_QueryConsumerChains_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} +) + func request_Query_QueryConsumerChains_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var protoReq QueryConsumerChainsRequest var metadata runtime.ServerMetadata + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_QueryConsumerChains_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + msg, err := client.QueryConsumerChains(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err @@ -190,6 +201,13 @@ func local_request_Query_QueryConsumerChains_0(ctx context.Context, marshaler ru var protoReq QueryConsumerChainsRequest var metadata runtime.ServerMetadata + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_QueryConsumerChains_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + msg, err := server.QueryConsumerChains(ctx, &protoReq) return msg, metadata, err