From 5656e8647bdaeb7330cbfe7b25b33082f3d63ce2 Mon Sep 17 00:00:00 2001 From: SaReN Date: Tue, 14 Jul 2020 23:11:30 +0530 Subject: [PATCH] x/staking: gRPC query Service (#6490) * Add types for staking grpc * Update module.go * Update staking query types * Add grpc query methods * Add delegation response to proto * Add queriers for delegations * Add queriers for unbonding * Add queriers for redelegations * Add cases for redelegations * Add test for grpc validators * Update staking types to proto * Update staking query proto * Add tests for grpc * Add tests for grpc pool, parameters * Fix lint issues * Add grpc redelegation tests * Add more tests * Add docs for query proto * Add docs for query types * Modify redel querier * Add debugging statements * Revert debugging * Fix proto lint errors * Add wrapper for keeper * Embed keeper in querier * Add more tests * Add tests for validator unbondings * Add redel tests * fix queryRedelegationsFromSrcValidator * Fix Redelegation tests * update godoc * Update args * Update tests with suite * Fix lint * Remove redundant types * Refactor tests * fix test * refactor query proto * Fix tests * address review comments * lint staking proto * add godoc * Update tests to table driven tests * add debugging * Fix grpc tests * address comments * address whitespace suggestions * Add more tests * add tests for invalid redels * update error messages * address review suggestions * add tests * move suite to keeper_test Co-authored-by: Aaron Craelius Co-authored-by: Federico Kunze <31522760+fedekunze@users.noreply.github.com> Co-authored-by: mergify[bot] <37929162+mergify[bot]@users.noreply.github.com> --- proto/cosmos/staking/query.proto | 228 + proto/cosmos/staking/staking.proto | 48 + x/slashing/client/rest/query.go | 2 +- x/slashing/keeper/querier.go | 2 +- x/slashing/types/querier.go | 15 - x/staking/client/cli/cli_test.go | 2 +- x/staking/client/cli/query.go | 6 +- x/staking/client/rest/query.go | 2 +- x/staking/client/rest/utils.go | 2 +- x/staking/keeper/grpc_query.go | 450 ++ x/staking/keeper/grpc_query_test.go | 732 +++ x/staking/keeper/keeper_test.go | 39 + x/staking/keeper/querier.go | 24 +- x/staking/keeper/querier_test.go | 46 +- x/staking/types/delegation.go | 49 - x/staking/types/pool.go | 16 - x/staking/types/querier.go | 28 - x/staking/types/query.pb.go | 6847 +++++++++++++++++++++++++++ x/staking/types/staking.pb.go | 1904 +++++++- 19 files changed, 10156 insertions(+), 286 deletions(-) create mode 100644 proto/cosmos/staking/query.proto create mode 100644 x/staking/keeper/grpc_query.go create mode 100644 x/staking/keeper/grpc_query_test.go create mode 100644 x/staking/types/query.pb.go diff --git a/proto/cosmos/staking/query.proto b/proto/cosmos/staking/query.proto new file mode 100644 index 000000000000..c37add5c1146 --- /dev/null +++ b/proto/cosmos/staking/query.proto @@ -0,0 +1,228 @@ +syntax = "proto3"; +package cosmos.staking; + +import "cosmos/query/pagination.proto"; +import "gogoproto/gogo.proto"; +import "cosmos/staking/staking.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/x/staking/types"; + +// Query defines the gRPC querier service +service Query { + // Validators queries all validators that match the given status + rpc Validators (QueryValidatorsRequest) returns (QueryValidatorsResponse) {} + + // Validator queries validator info for given validator addr + rpc Validator (QueryValidatorRequest) returns (QueryValidatorResponse) {} + + // ValidatorDelegations queries delegate info for given validator + rpc ValidatorDelegations (QueryValidatorDelegationsRequest) returns (QueryValidatorDelegationsResponse) {} + + // ValidatorUnbondingDelegations queries unbonding delegations of a validator + rpc ValidatorUnbondingDelegations (QueryValidatorUnbondingDelegationsRequest) returns (QueryValidatorUnbondingDelegationsResponse) {} + + // Delegation queries delegate info for given validator delegator pair + rpc Delegation (QueryDelegationRequest) returns (QueryDelegationResponse) {} + + // UnbondingDelegation queries unbonding info for give validator delegator pair + rpc UnbondingDelegation (QueryUnbondingDelegationRequest) returns (QueryUnbondingDelegationResponse) {} + + // DelegatorDelegations queries all delegations of a give delegator address + rpc DelegatorDelegations (QueryDelegatorDelegationsRequest) returns (QueryDelegatorDelegationsResponse) {} + + // DelegatorUnbondingDelegations queries all unbonding delegations of a give delegator address + rpc DelegatorUnbondingDelegations (QueryDelegatorUnbondingDelegationsRequest) returns (QueryDelegatorUnbondingDelegationsResponse) {} + + // Redelegations queries redelegations of given address + rpc Redelegations (QueryRedelegationsRequest) returns (QueryRedelegationsResponse) {} + + // DelegatorValidators queries all validator info for given delegator address + rpc DelegatorValidators (QueryDelegatorValidatorsRequest) returns (QueryDelegatorValidatorsResponse) {} + + // DelegatorValidator queries validator info for given delegator validator pair + rpc DelegatorValidator (QueryDelegatorValidatorRequest) returns (QueryDelegatorValidatorResponse) {} + + // HistoricalInfo queries the historical info for given height + rpc HistoricalInfo (QueryHistoricalInfoRequest) returns (QueryHistoricalInfoResponse) {} + + // Pool queries the pool info + rpc Pool (QueryPoolRequest) returns (QueryPoolResponse) {} + + // Parameters queries the staking parameters + rpc Params (QueryParamsRequest) returns (QueryParamsResponse) {} +} + +// QueryValidatorsRequest is request type for Query/Validators RPC method +message QueryValidatorsRequest{ + string status = 1; + + cosmos.query.PageRequest req = 2; +} + +// QueryValidatorsResponse is response type for the Query/Validators RPC method +message QueryValidatorsResponse { + repeated cosmos.staking.Validator validators = 1 [(gogoproto.nullable) = false]; + + cosmos.query.PageResponse res = 2; +} + +// QueryValidatorRequest is response type for the Query/Validator RPC method +message QueryValidatorRequest { + bytes validator_addr = 1 [(gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.ValAddress"]; +} + +// QueryValidatorResponse is response type for the Query/Validator RPC method +message QueryValidatorResponse { + Validator validator = 1 [(gogoproto.nullable) = false]; +} + +// QueryValidatorDelegationsRequest is request type for the Query/ValidatorDelegations RPC method +message QueryValidatorDelegationsRequest { + bytes validator_addr = 1 [(gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.ValAddress"]; + + cosmos.query.PageRequest req = 2; +} + +// QueryValidatorDelegationsRequest is response type for the Query/ValidatorDelegations RPC method +message QueryValidatorDelegationsResponse { + repeated DelegationResponse delegation_responses = 1 [(gogoproto.nullable) = false, (gogoproto.castrepeated) = "DelegationResponses"]; + + cosmos.query.PageResponse res = 2; +} + +// QueryValidatorUnbondingDelegationsRequest is required type for the Query/ValidatorUnbondingDelegations RPC method +message QueryValidatorUnbondingDelegationsRequest { + bytes validator_addr = 1 [(gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.ValAddress"]; + + cosmos.query.PageRequest req = 2; +} + +// QueryValidatorUnbondingDelegationsResponse is response type for the Query/ValidatorUnbondingDelegations RPC method +message QueryValidatorUnbondingDelegationsResponse { + repeated UnbondingDelegation unbonding_responses = 1 [(gogoproto.nullable) = false]; + + cosmos.query.PageResponse res = 2; +} + +// QueryDelegationRequest is request type for the Query/Delegation RPC method +message QueryDelegationRequest { + bytes delegator_addr = 1 [(gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.AccAddress"]; + + bytes validator_addr = 2 [(gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.ValAddress"]; +} + +// QueryDelegationResponse is response type for the Query/Delegation RPC method +message QueryDelegationResponse { + DelegationResponse delegation_response = 1 [(gogoproto.casttype) = "DelegationResponse"]; +} + +// QueryUnbondingDelegationRequest is request type for the Query/UnbondingDelegation RPC method +message QueryUnbondingDelegationRequest { + bytes delegator_addr = 1 [(gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.AccAddress"]; + + bytes validator_addr = 2 [(gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.ValAddress"]; +} + +// QueryDelegationResponse is response type for the Query/UnbondingDelegation RPC method +message QueryUnbondingDelegationResponse { + UnbondingDelegation unbond =1 [(gogoproto.nullable) = false]; +} + +// QueryDelegatorDelegationsRequest is request type for the Query/DelegatorDelegations RPC method +message QueryDelegatorDelegationsRequest { + bytes delegator_addr = 1 [(gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.AccAddress"]; + + cosmos.query.PageRequest req = 2; +} + +// QueryDelegatorDelegationsResponse is response type for the Query/DelegatorDelegations RPC method +message QueryDelegatorDelegationsResponse { + repeated DelegationResponse delegation_responses = 1 [(gogoproto.nullable) = false]; + + cosmos.query.PageResponse res = 2; +} + +// QueryDelegatorUnbondingDelegationsRequest is request type for the Query/DelegatorUnbondingDelegations RPC method +message QueryDelegatorUnbondingDelegationsRequest { + bytes delegator_addr = 1 [(gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.AccAddress"]; + + cosmos.query.PageRequest req = 2; +} +// QueryUnbondingDelegatorDelegationsResponse is response type for the Query/UnbondingDelegatorDelegations RPC method +message QueryDelegatorUnbondingDelegationsResponse { + repeated UnbondingDelegation unbonding_responses = 1 [(gogoproto.nullable) = false]; + + cosmos.query.PageResponse res = 2; +} + +// QueryRedelegationsRequest is request type for the Query/Redelegations RPC method +message QueryRedelegationsRequest { + bytes delegator_addr = 1 [(gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.AccAddress"]; + + bytes src_validator_addr = 2 [(gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.ValAddress"]; + + bytes dst_validator_addr = 3 [(gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.ValAddress"]; + + cosmos.query.PageRequest req = 4; +} + +// QueryRedelegationsResponse is response type for the Query/Redelegations RPC method +message QueryRedelegationsResponse { + repeated RedelegationResponse redelegation_responses = 1 [(gogoproto.nullable) = false]; + + cosmos.query.PageResponse res = 2; +} + +// QueryDelegatorValidatorsRequest is request type for the Query/DelegatorValidators RPC method +message QueryDelegatorValidatorsRequest { + bytes delegator_addr = 1 [(gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.AccAddress"]; + + cosmos.query.PageRequest req = 2; +} + +// QueryDelegatorValidatorsResponse is response type for the Query/DelegatorValidators RPC method +message QueryDelegatorValidatorsResponse { + repeated Validator validators = 1 [(gogoproto.nullable) = false]; + + cosmos.query.PageResponse res = 2; +} + +// QueryDelegatorValidatorRequest is request type for the Query/DelegatorValidator RPC method +message QueryDelegatorValidatorRequest { + bytes delegator_addr = 1 [(gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.AccAddress"]; + + bytes validator_addr = 2 [(gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.ValAddress"]; +} + +// QueryDelegatorValidatorResponse response type for the Query/DelegatorValidator RPC method +message QueryDelegatorValidatorResponse { + Validator validator = 1 [(gogoproto.nullable) = false]; +} + +// QueryHistoricalInfoRequest is request type for the Query/HistoricalInfo RPC method +message QueryHistoricalInfoRequest { + int64 height = 1; +} + +// QueryHistoricalInfoResponse is response type for the Query/HistoricalInfo RPC method +message QueryHistoricalInfoResponse { + HistoricalInfo hist = 1; +} + +// QueryPoolRequest is request type for the Query/Pool RPC method +message QueryPoolRequest { } + +// QueryPoolResponse is response type for the Query/Pool RPC method +message QueryPoolResponse { + Pool pool = 1 [(gogoproto.nullable) = false]; +} + +// QueryParametersRequest is request type for the Query/Parameters RPC method +message QueryParamsRequest { } + +// QueryParametersResponse is response type for the Query/Parameters RPC method +message QueryParamsResponse { + Params params = 1 [(gogoproto.nullable) = false]; + + cosmos.query.PageResponse res = 2; +} \ No newline at end of file diff --git a/proto/cosmos/staking/staking.proto b/proto/cosmos/staking/staking.proto index ddcf36b400a2..d375ff8f21d5 100644 --- a/proto/cosmos/staking/staking.proto +++ b/proto/cosmos/staking/staking.proto @@ -376,3 +376,51 @@ message Params { uint32 historical_entries = 4 [(gogoproto.moretags) = "yaml:\"historical_entries\""]; string bond_denom = 5 [(gogoproto.moretags) = "yaml:\"bond_denom\""]; } + +// DelegationResponse is equivalent to Delegation except that it contains a balance +// in addition to shares which is more suitable for client responses. +message DelegationResponse { + option (gogoproto.equal) = true; + option (gogoproto.goproto_stringer) = false; + + Delegation delegation = 1 [(gogoproto.nullable) = false]; + + cosmos.Coin balance = 2 [(gogoproto.nullable) = false]; +} + +// RedelegationEntryResponse is equivalent to a RedelegationEntry except that it +// contains a balance in addition to shares which is more suitable for client +// responses. +message RedelegationEntryResponse { + option (gogoproto.equal) = true; + + RedelegationEntry redelegation_entry = 1 [(gogoproto.nullable) = false]; + string balance = 4 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.nullable) = false + ]; +} + +// RedelegationResponse is equivalent to a Redelegation except that its entries +// contain a balance in addition to shares which is more suitable for client +// responses. +message RedelegationResponse { + option (gogoproto.equal) = true; + + Redelegation redelegation = 1 [(gogoproto.nullable) = false]; + repeated RedelegationEntryResponse entries = 2 [(gogoproto.nullable) = false]; +} + +// Pool - tracking bonded and not-bonded token supply of the bond denomination +message Pool { + option (gogoproto.description) = true; + option (gogoproto.equal) = true; + string not_bonded_tokens = 1 [(gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.jsontag) = "not_bonded_tokens", + (gogoproto.nullable) = false]; + string bonded_tokens = 2 [(gogoproto.jsontag) = "bonded_tokens", + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.nullable) = false, + (gogoproto.moretags) = "yaml:\"bonded_tokens\""]; +} + diff --git a/x/slashing/client/rest/query.go b/x/slashing/client/rest/query.go index 179b17f75422..3fb4278f2e55 100644 --- a/x/slashing/client/rest/query.go +++ b/x/slashing/client/rest/query.go @@ -43,7 +43,7 @@ func signingInfoHandlerFn(clientCtx client.Context) http.HandlerFunc { return } - params := types.NewQuerySigningInfoParams(sdk.ConsAddress(pk.Address())) + params := types.QuerySigningInfoRequest{ConsAddress: sdk.ConsAddress(pk.Address())} bz, err := clientCtx.JSONMarshaler.MarshalJSON(params) if rest.CheckBadRequestError(w, err) { diff --git a/x/slashing/keeper/querier.go b/x/slashing/keeper/querier.go index 1eab719a63f7..f44a1639af90 100644 --- a/x/slashing/keeper/querier.go +++ b/x/slashing/keeper/querier.go @@ -41,7 +41,7 @@ func queryParams(ctx sdk.Context, k Keeper) ([]byte, error) { } func querySigningInfo(ctx sdk.Context, req abci.RequestQuery, k Keeper) ([]byte, error) { - var params types.QuerySigningInfoParams + var params types.QuerySigningInfoRequest err := types.ModuleCdc.UnmarshalJSON(req.Data, ¶ms) if err != nil { diff --git a/x/slashing/types/querier.go b/x/slashing/types/querier.go index b149886c321b..3820a65264f6 100644 --- a/x/slashing/types/querier.go +++ b/x/slashing/types/querier.go @@ -1,9 +1,5 @@ package types -import ( - sdk "github.com/cosmos/cosmos-sdk/types" -) - // DONTCOVER // Query endpoints supported by the slashing querier @@ -13,17 +9,6 @@ const ( QuerySigningInfos = "signingInfos" ) -// QuerySigningInfoParams defines the params for the following queries: -// - 'custom/slashing/signingInfo' -type QuerySigningInfoParams struct { - ConsAddress sdk.ConsAddress -} - -// NewQuerySigningInfoParams creates a new QuerySigningInfoParams instance -func NewQuerySigningInfoParams(consAddr sdk.ConsAddress) QuerySigningInfoParams { - return QuerySigningInfoParams{consAddr} -} - // QuerySigningInfosParams defines the params for the following queries: // - 'custom/slashing/signingInfos' type QuerySigningInfosParams struct { diff --git a/x/staking/client/cli/cli_test.go b/x/staking/client/cli/cli_test.go index 4bb58b05a592..20ce2a74b35b 100644 --- a/x/staking/client/cli/cli_test.go +++ b/x/staking/client/cli/cli_test.go @@ -74,7 +74,7 @@ func TestCLICreateValidator(t *testing.T) { // Query delegations to the validator validatorDelegations := testutil.QueryStakingDelegationsTo(f, barVal) require.Len(t, validatorDelegations, 1) - require.NotZero(t, validatorDelegations[0].Shares) + require.NotNil(t, validatorDelegations[0].Shares) // Edit validator // params to be changed in edit validator (NOTE: a validator can only change its commission once per day) diff --git a/x/staking/client/cli/query.go b/x/staking/client/cli/query.go index 9608bda977bb..46dabb3603b7 100644 --- a/x/staking/client/cli/query.go +++ b/x/staking/client/cli/query.go @@ -258,7 +258,7 @@ $ %s query staking delegation cosmos1gghjut3ccd8ay0zduzj64hwre2fxs9ld75ru9p cosm return err } - bz, err := cdc.MarshalJSON(types.NewQueryBondsParams(delAddr, valAddr)) + bz, err := cdc.MarshalJSON(types.QueryDelegatorValidatorRequest{DelegatorAddr: delAddr, ValidatorAddr: valAddr}) if err != nil { return err } @@ -414,7 +414,7 @@ $ %s query staking unbonding-delegation cosmos1gghjut3ccd8ay0zduzj64hwre2fxs9ld7 return err } - bz, err := cdc.MarshalJSON(types.NewQueryBondsParams(delAddr, valAddr)) + bz, err := cdc.MarshalJSON(types.QueryDelegatorValidatorRequest{DelegatorAddr: delAddr, ValidatorAddr: valAddr}) if err != nil { return err } @@ -619,7 +619,7 @@ $ %s query staking historical-info 5 return fmt.Errorf("height argument provided must be a non-negative-integer: %v", err) } - bz, err := cdc.MarshalJSON(types.QueryHistoricalInfoParams{Height: height}) + bz, err := cdc.MarshalJSON(types.QueryHistoricalInfoRequest{Height: height}) if err != nil { return err } diff --git a/x/staking/client/rest/query.go b/x/staking/client/rest/query.go index 2dabef40c45c..27e458d9b301 100644 --- a/x/staking/client/rest/query.go +++ b/x/staking/client/rest/query.go @@ -328,7 +328,7 @@ func historicalInfoHandlerFn(clientCtx client.Context) http.HandlerFunc { return } - params := types.NewQueryHistoricalInfoParams(height) + params := types.QueryHistoricalInfoRequest{Height: height} bz, err := clientCtx.JSONMarshaler.MarshalJSON(params) if rest.CheckInternalServerError(w, err) { diff --git a/x/staking/client/rest/utils.go b/x/staking/client/rest/utils.go index 185c4562b949..6cc30499bfff 100644 --- a/x/staking/client/rest/utils.go +++ b/x/staking/client/rest/utils.go @@ -57,7 +57,7 @@ func queryBonds(clientCtx client.Context, endpoint string) http.HandlerFunc { return } - params := types.NewQueryBondsParams(delegatorAddr, validatorAddr) + params := types.QueryDelegatorValidatorRequest{DelegatorAddr: delegatorAddr, ValidatorAddr: validatorAddr} bz, err := clientCtx.JSONMarshaler.MarshalJSON(params) if rest.CheckBadRequestError(w, err) { diff --git a/x/staking/keeper/grpc_query.go b/x/staking/keeper/grpc_query.go new file mode 100644 index 000000000000..d0f22714b1ba --- /dev/null +++ b/x/staking/keeper/grpc_query.go @@ -0,0 +1,450 @@ +package keeper + +import ( + "context" + "strings" + + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" + + "github.com/cosmos/cosmos-sdk/store/prefix" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/types/query" + "github.com/cosmos/cosmos-sdk/x/staking/types" +) + +// Querier is used as Keeper will have duplicate methods if used directly, and gRPC names take precedence over keeper +type Querier struct { + Keeper +} + +var _ types.QueryServer = Querier{} + +// Validators queries all validators that match the given status +func (k Querier) Validators(c context.Context, req *types.QueryValidatorsRequest) (*types.QueryValidatorsResponse, error) { + if req == nil { + return nil, status.Error(codes.InvalidArgument, "empty request") + } + + if req.Status == "" { + return nil, status.Error(codes.InvalidArgument, "status cannot be empty") + } + if !(req.Status == sdk.Bonded.String() || req.Status == sdk.Unbonded.String() || req.Status == sdk.Unbonding.String()) { + return nil, status.Errorf(codes.InvalidArgument, "invalid validator status %s", req.Status) + } + var validators types.Validators + ctx := sdk.UnwrapSDKContext(c) + + store := ctx.KVStore(k.storeKey) + valStore := prefix.NewStore(store, types.ValidatorsKey) + + res, err := query.FilteredPaginate(valStore, req.Req, func(key []byte, value []byte, accumulate bool) (bool, error) { + val, err := types.UnmarshalValidator(k.cdc, value) + if err != nil { + return false, err + } + + if req.Status != "" && !strings.EqualFold(val.GetStatus().String(), req.Status) { + return false, nil + } + + if accumulate { + validators = append(validators, val) + } + return true, nil + }) + + if err != nil { + return nil, status.Error(codes.Internal, err.Error()) + } + + return &types.QueryValidatorsResponse{Validators: validators, Res: res}, nil +} + +// Validator queries validator info for given validator addr +func (k Querier) Validator(c context.Context, req *types.QueryValidatorRequest) (*types.QueryValidatorResponse, error) { + if req == nil { + return nil, status.Error(codes.InvalidArgument, "empty request") + } + + if req.ValidatorAddr.Empty() { + return nil, status.Error(codes.InvalidArgument, "validator address cannot be empty") + } + ctx := sdk.UnwrapSDKContext(c) + validator, found := k.GetValidator(ctx, req.ValidatorAddr) + if !found { + return nil, status.Errorf(codes.NotFound, "validator %s not found", req.ValidatorAddr) + } + + return &types.QueryValidatorResponse{Validator: validator}, nil +} + +// ValidatorDelegations queries delegate info for given validator +func (k Querier) ValidatorDelegations(c context.Context, req *types.QueryValidatorDelegationsRequest) (*types.QueryValidatorDelegationsResponse, error) { + if req == nil { + return nil, status.Error(codes.InvalidArgument, "empty request") + } + + if req.ValidatorAddr.Empty() { + return nil, status.Error(codes.InvalidArgument, "validator address cannot be empty") + } + var delegations []types.Delegation + ctx := sdk.UnwrapSDKContext(c) + + store := ctx.KVStore(k.storeKey) + valStore := prefix.NewStore(store, types.DelegationKey) + res, err := query.FilteredPaginate(valStore, req.Req, func(key []byte, value []byte, accumulate bool) (bool, error) { + delegation, err := types.UnmarshalDelegation(k.cdc, value) + if err != nil { + return false, err + } + if !delegation.GetValidatorAddr().Equals(req.ValidatorAddr) { + return false, nil + } + + if accumulate { + delegations = append(delegations, delegation) + } + return true, nil + }) + if err != nil { + return nil, status.Error(codes.Internal, err.Error()) + } + + delResponses, err := DelegationsToDelegationResponses(ctx, k.Keeper, delegations) + if err != nil { + return nil, status.Error(codes.Internal, err.Error()) + } + + return &types.QueryValidatorDelegationsResponse{ + DelegationResponses: delResponses, Res: res}, nil +} + +// ValidatorUnbondingDelegations queries unbonding delegations of a validator +func (k Querier) ValidatorUnbondingDelegations(c context.Context, req *types.QueryValidatorUnbondingDelegationsRequest) (*types.QueryValidatorUnbondingDelegationsResponse, error) { + if req == nil { + return nil, status.Error(codes.InvalidArgument, "empty request") + } + + if req.ValidatorAddr.Empty() { + return nil, status.Error(codes.InvalidArgument, "validator address cannot be empty") + } + var ubds types.UnbondingDelegations + ctx := sdk.UnwrapSDKContext(c) + + store := ctx.KVStore(k.storeKey) + ubdStore := prefix.NewStore(store, types.GetUBDsByValIndexKey(req.ValidatorAddr)) + res, err := query.Paginate(ubdStore, req.Req, func(key []byte, value []byte) error { + ubd, err := types.UnmarshalUBD(k.cdc, value) + if err != nil { + return err + } + ubds = append(ubds, ubd) + return nil + }) + if err != nil { + return nil, status.Error(codes.Internal, err.Error()) + } + + return &types.QueryValidatorUnbondingDelegationsResponse{ + UnbondingResponses: ubds, + Res: res, + }, nil +} + +// Delegation queries delegate info for given validator delegator pair +func (k Querier) Delegation(c context.Context, req *types.QueryDelegationRequest) (*types.QueryDelegationResponse, error) { + if req == nil { + return nil, status.Error(codes.InvalidArgument, "empty request") + } + + if req.DelegatorAddr.Empty() { + return nil, status.Error(codes.InvalidArgument, "delegator address cannot be empty") + } + if req.ValidatorAddr.Empty() { + return nil, status.Error(codes.InvalidArgument, "validator address cannot be empty") + } + + ctx := sdk.UnwrapSDKContext(c) + delegation, found := k.GetDelegation(ctx, req.DelegatorAddr, req.ValidatorAddr) + if !found { + return nil, status.Errorf( + codes.NotFound, + "delegation with delegator %s not found for validator %s", + req.DelegatorAddr, req.ValidatorAddr) + } + + delResponse, err := DelegationToDelegationResponse(ctx, k.Keeper, delegation) + if err != nil { + return nil, status.Error(codes.Internal, err.Error()) + } + + return &types.QueryDelegationResponse{DelegationResponse: &delResponse}, nil +} + +// UnbondingDelegation queries unbonding info for give validator delegator pair +func (k Querier) UnbondingDelegation(c context.Context, req *types.QueryUnbondingDelegationRequest) (*types.QueryUnbondingDelegationResponse, error) { + if req == nil { + return nil, status.Errorf(codes.InvalidArgument, "empty request") + } + + if req.DelegatorAddr.Empty() { + return nil, status.Errorf(codes.InvalidArgument, "delegator address cannot be empty") + } + if req.ValidatorAddr.Empty() { + return nil, status.Errorf(codes.InvalidArgument, "validator address cannot be empty") + } + + ctx := sdk.UnwrapSDKContext(c) + unbond, found := k.GetUnbondingDelegation(ctx, req.DelegatorAddr, req.ValidatorAddr) + if !found { + return nil, status.Errorf( + codes.NotFound, + "unbonding delegation with delegator %s not found for validator %s", + req.DelegatorAddr, req.ValidatorAddr) + } + + return &types.QueryUnbondingDelegationResponse{Unbond: unbond}, nil +} + +// DelegatorDelegations queries all delegations of a give delegator address +func (k Querier) DelegatorDelegations(c context.Context, req *types.QueryDelegatorDelegationsRequest) (*types.QueryDelegatorDelegationsResponse, error) { + if req == nil { + return nil, status.Errorf(codes.InvalidArgument, "empty request") + } + + if req.DelegatorAddr.Empty() { + return nil, status.Error(codes.InvalidArgument, "delegator address cannot be empty") + } + var delegations types.Delegations + ctx := sdk.UnwrapSDKContext(c) + + store := ctx.KVStore(k.storeKey) + delStore := prefix.NewStore(store, types.GetDelegationsKey(req.DelegatorAddr)) + res, err := query.Paginate(delStore, req.Req, func(key []byte, value []byte) error { + delegation, err := types.UnmarshalDelegation(k.cdc, value) + if err != nil { + return err + } + delegations = append(delegations, delegation) + return nil + }) + if err != nil { + return nil, status.Error(codes.Internal, err.Error()) + } + + if delegations == nil { + return nil, status.Errorf( + codes.NotFound, + "unable to find delegations for address %s", req.DelegatorAddr) + } + delegationResps, err := DelegationsToDelegationResponses(ctx, k.Keeper, delegations) + if err != nil { + return nil, status.Error(codes.Internal, err.Error()) + } + + return &types.QueryDelegatorDelegationsResponse{DelegationResponses: delegationResps, Res: res}, nil + +} + +// DelegatorValidator queries validator info for given delegator validator pair +func (k Querier) DelegatorValidator(c context.Context, req *types.QueryDelegatorValidatorRequest) (*types.QueryDelegatorValidatorResponse, error) { + if req == nil { + return nil, status.Error(codes.InvalidArgument, "empty request") + } + + if req.DelegatorAddr.Empty() { + return nil, status.Error(codes.InvalidArgument, "delegator address cannot be empty") + } + if req.ValidatorAddr.Empty() { + return nil, status.Error(codes.InvalidArgument, "validator address cannot be empty") + } + + ctx := sdk.UnwrapSDKContext(c) + validator, err := k.GetDelegatorValidator(ctx, req.DelegatorAddr, req.ValidatorAddr) + if err != nil { + return nil, status.Error(codes.Internal, err.Error()) + } + + return &types.QueryDelegatorValidatorResponse{Validator: validator}, nil +} + +// DelegatorUnbondingDelegations queries all unbonding delegations of a give delegator address +func (k Querier) DelegatorUnbondingDelegations(c context.Context, req *types.QueryDelegatorUnbondingDelegationsRequest) (*types.QueryDelegatorUnbondingDelegationsResponse, error) { + if req == nil { + return nil, status.Error(codes.InvalidArgument, "empty request") + } + + if req.DelegatorAddr.Empty() { + return nil, status.Error(codes.InvalidArgument, "delegator address cannot be empty") + } + var unbondingDelegations types.UnbondingDelegations + ctx := sdk.UnwrapSDKContext(c) + + store := ctx.KVStore(k.storeKey) + unbStore := prefix.NewStore(store, types.GetUBDsKey(req.DelegatorAddr)) + res, err := query.Paginate(unbStore, req.Req, func(key []byte, value []byte) error { + unbond, err := types.UnmarshalUBD(k.cdc, value) + if err != nil { + return err + } + unbondingDelegations = append(unbondingDelegations, unbond) + return nil + }) + if err != nil { + return nil, status.Error(codes.Internal, err.Error()) + } + + return &types.QueryDelegatorUnbondingDelegationsResponse{ + UnbondingResponses: unbondingDelegations, Res: res}, nil +} + +// HistoricalInfo queries the historical info for given height +func (k Querier) HistoricalInfo(c context.Context, req *types.QueryHistoricalInfoRequest) (*types.QueryHistoricalInfoResponse, error) { + if req == nil { + return nil, status.Error(codes.InvalidArgument, "empty request") + } + + if req.Height < 0 { + return nil, status.Error(codes.InvalidArgument, "height cannot be negative") + } + ctx := sdk.UnwrapSDKContext(c) + hi, found := k.GetHistoricalInfo(ctx, req.Height) + if !found { + return nil, status.Errorf(codes.NotFound, "historical info for height %d not found", req.Height) + } + + return &types.QueryHistoricalInfoResponse{Hist: &hi}, nil +} + +func (k Querier) Redelegations(c context.Context, req *types.QueryRedelegationsRequest) (*types.QueryRedelegationsResponse, error) { + if req == nil { + return nil, status.Error(codes.InvalidArgument, "empty request") + } + + var redels types.Redelegations + var res *query.PageResponse + var err error + + ctx := sdk.UnwrapSDKContext(c) + store := ctx.KVStore(k.storeKey) + switch { + case !req.DelegatorAddr.Empty() && !req.SrcValidatorAddr.Empty() && !req.DstValidatorAddr.Empty(): + redels, err = queryRedelegation(ctx, k, req) + case req.DelegatorAddr.Empty() && !req.SrcValidatorAddr.Empty() && req.DstValidatorAddr.Empty(): + redels, res, err = queryRedelegationsFromSrcValidator(store, k, req) + default: + redels, res, err = queryAllRedelegations(store, k, req) + } + if err != nil { + return nil, status.Error(codes.Internal, err.Error()) + } + redelResponses, err := RedelegationsToRedelegationResponses(ctx, k.Keeper, redels) + if err != nil { + return nil, status.Error(codes.Internal, err.Error()) + } + + return &types.QueryRedelegationsResponse{RedelegationResponses: redelResponses, Res: res}, nil +} + +func (k Querier) DelegatorValidators(c context.Context, req *types.QueryDelegatorValidatorsRequest) (*types.QueryDelegatorValidatorsResponse, error) { + if req == nil { + return nil, status.Error(codes.InvalidArgument, "empty request") + } + + if req.DelegatorAddr.Empty() { + return nil, status.Error(codes.InvalidArgument, "delegator address cannot be empty") + } + var validators types.Validators + ctx := sdk.UnwrapSDKContext(c) + + store := ctx.KVStore(k.storeKey) + delStore := prefix.NewStore(store, types.GetDelegationsKey(req.DelegatorAddr)) + res, err := query.Paginate(delStore, req.Req, func(key []byte, value []byte) error { + delegation, err := types.UnmarshalDelegation(k.cdc, value) + if err != nil { + return err + } + + validator, found := k.GetValidator(ctx, delegation.ValidatorAddress) + if !found { + return types.ErrNoValidatorFound + } + + validators = append(validators, validator) + return nil + }) + + if err != nil { + return nil, status.Error(codes.Internal, err.Error()) + } + + return &types.QueryDelegatorValidatorsResponse{Validators: validators, Res: res}, nil +} + +// Pool queries the pool info +func (k Querier) Pool(c context.Context, _ *types.QueryPoolRequest) (*types.QueryPoolResponse, error) { + ctx := sdk.UnwrapSDKContext(c) + bondDenom := k.BondDenom(ctx) + bondedPool := k.GetBondedPool(ctx) + notBondedPool := k.GetNotBondedPool(ctx) + + pool := types.NewPool( + k.bankKeeper.GetBalance(ctx, notBondedPool.GetAddress(), bondDenom).Amount, + k.bankKeeper.GetBalance(ctx, bondedPool.GetAddress(), bondDenom).Amount, + ) + + return &types.QueryPoolResponse{Pool: pool}, nil +} + +// Params queries the staking parameters +func (k Querier) Params(c context.Context, _ *types.QueryParamsRequest) (*types.QueryParamsResponse, error) { + ctx := sdk.UnwrapSDKContext(c) + params := k.GetParams(ctx) + + return &types.QueryParamsResponse{Params: params}, nil +} + +func queryRedelegation(ctx sdk.Context, k Querier, req *types.QueryRedelegationsRequest) (redels types.Redelegations, err error) { + redel, found := k.GetRedelegation(ctx, req.DelegatorAddr, req.SrcValidatorAddr, req.DstValidatorAddr) + if !found { + return nil, status.Errorf( + codes.NotFound, + "redelegation not found for delegator address %s from validator address %s", + req.DelegatorAddr, req.SrcValidatorAddr) + } + redels = []types.Redelegation{redel} + + return redels, err +} + +func queryRedelegationsFromSrcValidator(store sdk.KVStore, k Querier, req *types.QueryRedelegationsRequest) (redels types.Redelegations, res *query.PageResponse, err error) { + srcValPrefix := types.GetREDsFromValSrcIndexKey(req.SrcValidatorAddr) + redStore := prefix.NewStore(store, srcValPrefix) + res, err = query.Paginate(redStore, req.Req, func(key []byte, value []byte) error { + storeKey := types.GetREDKeyFromValSrcIndexKey(append(srcValPrefix, key...)) + storeValue := store.Get(storeKey) + red, err := types.UnmarshalRED(k.cdc, storeValue) + if err != nil { + return err + } + redels = append(redels, red) + return nil + }) + + return redels, res, err +} + +func queryAllRedelegations(store sdk.KVStore, k Querier, req *types.QueryRedelegationsRequest) (redels types.Redelegations, res *query.PageResponse, err error) { + redStore := prefix.NewStore(store, types.GetREDsKey(req.DelegatorAddr)) + res, err = query.Paginate(redStore, req.Req, func(key []byte, value []byte) error { + redelegation, err := types.UnmarshalRED(k.cdc, value) + if err != nil { + return err + } + redels = append(redels, redelegation) + return nil + }) + + return redels, res, err +} diff --git a/x/staking/keeper/grpc_query_test.go b/x/staking/keeper/grpc_query_test.go new file mode 100644 index 000000000000..2cb88f46ff1b --- /dev/null +++ b/x/staking/keeper/grpc_query_test.go @@ -0,0 +1,732 @@ +package keeper_test + +import ( + gocontext "context" + "fmt" + + "github.com/cosmos/cosmos-sdk/simapp" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/types/query" + "github.com/cosmos/cosmos-sdk/x/staking/keeper" + "github.com/cosmos/cosmos-sdk/x/staking/types" +) + +func (suite *KeeperTestSuite) TestGRPCQueryValidators() { + queryClient, vals := suite.queryClient, suite.vals + var req *types.QueryValidatorsRequest + testCases := []struct { + msg string + malleate func() + expPass bool + }{ + { + "empty request", + func() { + req = &types.QueryValidatorsRequest{} + }, + false, + }, + {"invalid request with empty status", + func() { + req = &types.QueryValidatorsRequest{Status: ""} + }, + false, + }, + { + "invalid request", + func() { + req = &types.QueryValidatorsRequest{Status: "test"} + }, + false, + }, + {"valid request", + func() { + req = &types.QueryValidatorsRequest{Status: sdk.Bonded.String(), + Req: &query.PageRequest{Limit: 1, CountTotal: true}} + }, + true, + }, + } + for _, tc := range testCases { + suite.Run(fmt.Sprintf("Case %s", tc.msg), func() { + tc.malleate() + valsResp, err := queryClient.Validators(gocontext.Background(), req) + if tc.expPass { + suite.NoError(err) + suite.NotNil(valsResp) + suite.Equal(1, len(valsResp.Validators)) + suite.NotNil(valsResp.Res.NextKey) + suite.Equal(uint64(len(vals)), valsResp.Res.Total) + } else { + suite.Require().Error(err) + } + }) + } +} + +func (suite *KeeperTestSuite) TestGRPCValidator() { + app, ctx, queryClient, vals := suite.app, suite.ctx, suite.queryClient, suite.vals + validator, found := app.StakingKeeper.GetValidator(ctx, vals[0].OperatorAddress) + suite.True(found) + var req *types.QueryValidatorRequest + testCases := []struct { + msg string + malleate func() + expPass bool + }{ + { + "empty request", + func() { + req = &types.QueryValidatorRequest{} + }, + false, + }, + {"valid request", + func() { + req = &types.QueryValidatorRequest{ValidatorAddr: vals[0].OperatorAddress} + }, + true, + }, + } + + for _, tc := range testCases { + suite.Run(fmt.Sprintf("Case %s", tc.msg), func() { + tc.malleate() + res, err := queryClient.Validator(gocontext.Background(), req) + if tc.expPass { + suite.NoError(err) + suite.Equal(validator, res.Validator) + } else { + suite.Error(err) + suite.Nil(res) + } + }) + } +} + +func (suite *KeeperTestSuite) TestGRPCQueryDelegatorValidators() { + app, ctx, queryClient, addrs := suite.app, suite.ctx, suite.queryClient, suite.addrs + params := app.StakingKeeper.GetParams(ctx) + delValidators := app.StakingKeeper.GetDelegatorValidators(ctx, addrs[0], params.MaxValidators) + var req *types.QueryDelegatorValidatorsRequest + testCases := []struct { + msg string + malleate func() + expPass bool + }{ + { + "empty request", + func() { + req = &types.QueryDelegatorValidatorsRequest{} + }, + false, + }, + {"valid request", + func() { + req = &types.QueryDelegatorValidatorsRequest{ + DelegatorAddr: addrs[0], + Req: &query.PageRequest{Limit: 1, CountTotal: true}} + }, + true, + }, + } + + for _, tc := range testCases { + suite.Run(fmt.Sprintf("Case %s", tc.msg), func() { + tc.malleate() + res, err := queryClient.DelegatorValidators(gocontext.Background(), req) + if tc.expPass { + suite.NoError(err) + suite.Equal(1, len(res.Validators)) + suite.NotNil(res.Res.NextKey) + suite.Equal(uint64(len(delValidators)), res.Res.Total) + } else { + suite.Error(err) + suite.Nil(res) + } + }) + } +} + +func (suite *KeeperTestSuite) TestGRPCQueryDelegatorValidator() { + queryClient, addrs, vals := suite.queryClient, suite.addrs, suite.vals + addr := addrs[1] + addrVal, addrVal1 := vals[0].OperatorAddress, vals[1].OperatorAddress + var req *types.QueryDelegatorValidatorRequest + testCases := []struct { + msg string + malleate func() + expPass bool + }{ + { + "empty request", + func() { + req = &types.QueryDelegatorValidatorRequest{} + }, + false, + }, + {"invalid delegator, validator pair", + func() { + req = &types.QueryDelegatorValidatorRequest{ + DelegatorAddr: addr, + ValidatorAddr: addrVal, + } + }, + false, + }, + {"valid request", + func() { + req = &types.QueryDelegatorValidatorRequest{ + DelegatorAddr: addr, + ValidatorAddr: addrVal1, + } + }, + true, + }, + } + + for _, tc := range testCases { + suite.Run(fmt.Sprintf("Case %s", tc.msg), func() { + tc.malleate() + res, err := queryClient.DelegatorValidator(gocontext.Background(), req) + if tc.expPass { + suite.NoError(err) + suite.Equal(addrVal1, res.Validator.OperatorAddress) + } else { + suite.Error(err) + suite.Nil(res) + } + }) + } +} + +func (suite *KeeperTestSuite) TestGRPCQueryDelegation() { + app, ctx, queryClient, addrs, vals := suite.app, suite.ctx, suite.queryClient, suite.addrs, suite.vals + addrAcc, addrAcc1 := addrs[0], addrs[1] + addrVal := vals[0].OperatorAddress + + delegation, found := app.StakingKeeper.GetDelegation(ctx, addrAcc, addrVal) + suite.True(found) + var req *types.QueryDelegationRequest + + testCases := []struct { + msg string + malleate func() + expPass bool + }{ + {"empty request", + func() { + req = &types.QueryDelegationRequest{} + }, + false, + }, + {"invalid validator, delegator pair", + func() { + req = &types.QueryDelegationRequest{ + DelegatorAddr: addrAcc1, + ValidatorAddr: addrVal, + } + }, + false, + }, + {"valid request", + func() { + req = &types.QueryDelegationRequest{DelegatorAddr: addrAcc, ValidatorAddr: addrVal} + }, + true, + }, + } + + for _, tc := range testCases { + suite.Run(fmt.Sprintf("Case %s", tc.msg), func() { + tc.malleate() + res, err := queryClient.Delegation(gocontext.Background(), req) + if tc.expPass { + suite.Equal(delegation.ValidatorAddress, res.DelegationResponse.Delegation.ValidatorAddress) + suite.Equal(delegation.DelegatorAddress, res.DelegationResponse.Delegation.DelegatorAddress) + suite.Equal(sdk.NewCoin(sdk.DefaultBondDenom, delegation.Shares.TruncateInt()), res.DelegationResponse.Balance) + } else { + suite.Error(err) + suite.Nil(res) + } + }) + } +} + +func (suite *KeeperTestSuite) TestGRPCQueryDelegatorDelegations() { + app, ctx, queryClient, addrs, vals := suite.app, suite.ctx, suite.queryClient, suite.addrs, suite.vals + addrAcc := addrs[0] + addrVal1 := vals[0].OperatorAddress + + delegation, found := app.StakingKeeper.GetDelegation(ctx, addrAcc, addrVal1) + suite.True(found) + var req *types.QueryDelegatorDelegationsRequest + + testCases := []struct { + msg string + malleate func() + expPass bool + }{ + {"empty request", + func() { + req = &types.QueryDelegatorDelegationsRequest{} + }, + false, + }, {"invalid request", + func() { + req = &types.QueryDelegatorDelegationsRequest{DelegatorAddr: addrs[4]} + }, + false, + }, + {"valid request", + func() { + req = &types.QueryDelegatorDelegationsRequest{DelegatorAddr: addrAcc, + Req: &query.PageRequest{Limit: 1, CountTotal: true}} + }, + true, + }, + } + + for _, tc := range testCases { + suite.Run(fmt.Sprintf("Case %s", tc.msg), func() { + tc.malleate() + res, err := queryClient.DelegatorDelegations(gocontext.Background(), req) + if tc.expPass { + suite.Equal(uint64(2), res.Res.Total) + suite.Len(res.DelegationResponses, 1) + suite.Equal(1, len(res.DelegationResponses)) + suite.Equal(sdk.NewCoin(sdk.DefaultBondDenom, delegation.Shares.TruncateInt()), res.DelegationResponses[0].Balance) + } else { + suite.Error(err) + suite.Nil(res) + } + }) + } +} + +func (suite *KeeperTestSuite) TestGRPCQueryValidatorDelegations() { + app, ctx, queryClient, addrs, vals := suite.app, suite.ctx, suite.queryClient, suite.addrs, suite.vals + addrAcc := addrs[0] + addrVal1 := vals[1].OperatorAddress + valAddrs := simapp.ConvertAddrsToValAddrs(addrs) + addrVal2 := valAddrs[4] + + delegation, found := app.StakingKeeper.GetDelegation(ctx, addrAcc, addrVal1) + suite.True(found) + + var req *types.QueryValidatorDelegationsRequest + testCases := []struct { + msg string + malleate func() + expPass bool + expErr bool + }{ + {"empty request", + func() { + req = &types.QueryValidatorDelegationsRequest{} + }, + false, + true, + }, + {"invalid validator delegator pair", + func() { + req = &types.QueryValidatorDelegationsRequest{ValidatorAddr: addrVal2} + }, + false, + false, + }, + {"valid request", + func() { + req = &types.QueryValidatorDelegationsRequest{ValidatorAddr: addrVal1, + Req: &query.PageRequest{Limit: 1, CountTotal: true}} + }, + true, + false, + }, + } + + for _, tc := range testCases { + suite.Run(fmt.Sprintf("Case %s", tc.msg), func() { + tc.malleate() + res, err := queryClient.ValidatorDelegations(gocontext.Background(), req) + if tc.expPass && !tc.expErr { + suite.NoError(err) + suite.Len(res.DelegationResponses, 1) + suite.NotNil(res.Res.NextKey) + suite.Equal(uint64(2), res.Res.Total) + suite.Equal(addrVal1, res.DelegationResponses[0].Delegation.ValidatorAddress) + suite.Equal(sdk.NewCoin(sdk.DefaultBondDenom, delegation.Shares.TruncateInt()), res.DelegationResponses[0].Balance) + } else if !tc.expPass && !tc.expErr { + suite.NoError(err) + suite.Nil(res.DelegationResponses) + } else { + suite.Error(err) + suite.Nil(res) + } + }) + } +} + +func (suite *KeeperTestSuite) TestGRPCQueryUnbondingDelegation() { + app, ctx, queryClient, addrs, vals := suite.app, suite.ctx, suite.queryClient, suite.addrs, suite.vals + addrAcc2 := addrs[1] + addrVal2 := vals[1].OperatorAddress + + unbondingTokens := sdk.TokensFromConsensusPower(2) + _, err := app.StakingKeeper.Undelegate(ctx, addrAcc2, addrVal2, unbondingTokens.ToDec()) + suite.NoError(err) + + unbond, found := app.StakingKeeper.GetUnbondingDelegation(ctx, addrAcc2, addrVal2) + suite.True(found) + var req *types.QueryUnbondingDelegationRequest + testCases := []struct { + msg string + malleate func() + expPass bool + }{ + {"empty request", + func() { + req = &types.QueryUnbondingDelegationRequest{} + }, + false, + }, + {"invalid request", + func() { + req = &types.QueryUnbondingDelegationRequest{} + }, + false, + }, + {"valid request", + func() { + req = &types.QueryUnbondingDelegationRequest{ + DelegatorAddr: addrAcc2, ValidatorAddr: addrVal2} + }, + true, + }, + } + + for _, tc := range testCases { + suite.Run(fmt.Sprintf("Case %s", tc.msg), func() { + tc.malleate() + res, err := queryClient.UnbondingDelegation(gocontext.Background(), req) + if tc.expPass { + suite.NotNil(res) + suite.Equal(unbond, res.Unbond) + } else { + suite.Error(err) + suite.Nil(res) + } + }) + } +} + +func (suite *KeeperTestSuite) TestGRPCQueryDelegatorUnbondingDelegations() { + app, ctx, queryClient, addrs, vals := suite.app, suite.ctx, suite.queryClient, suite.addrs, suite.vals + addrAcc, addrAcc1 := addrs[0], addrs[1] + addrVal, addrVal2 := vals[0].OperatorAddress, vals[1].OperatorAddress + + unbondingTokens := sdk.TokensFromConsensusPower(2) + _, err := app.StakingKeeper.Undelegate(ctx, addrAcc, addrVal, unbondingTokens.ToDec()) + suite.NoError(err) + _, err = app.StakingKeeper.Undelegate(ctx, addrAcc, addrVal2, unbondingTokens.ToDec()) + suite.NoError(err) + + unbond, found := app.StakingKeeper.GetUnbondingDelegation(ctx, addrAcc, addrVal) + suite.True(found) + var req *types.QueryDelegatorUnbondingDelegationsRequest + testCases := []struct { + msg string + malleate func() + expPass bool + expErr bool + }{ + {"empty request", + func() { + req = &types.QueryDelegatorUnbondingDelegationsRequest{} + }, + false, + true, + }, + {"invalid request", + func() { + req = &types.QueryDelegatorUnbondingDelegationsRequest{DelegatorAddr: addrAcc1} + }, + false, + false, + }, + {"valid request", + func() { + req = &types.QueryDelegatorUnbondingDelegationsRequest{DelegatorAddr: addrAcc, + Req: &query.PageRequest{Limit: 1, CountTotal: true}} + }, + true, + false, + }, + } + + for _, tc := range testCases { + suite.Run(fmt.Sprintf("Case %s", tc.msg), func() { + tc.malleate() + res, err := queryClient.DelegatorUnbondingDelegations(gocontext.Background(), req) + if tc.expPass && !tc.expErr { + suite.NoError(err) + suite.NotNil(res.Res.NextKey) + suite.Equal(uint64(2), res.Res.Total) + suite.Len(res.UnbondingResponses, 1) + suite.Equal(unbond, res.UnbondingResponses[0]) + } else if !tc.expPass && !tc.expErr { + suite.NoError(err) + suite.Nil(res.UnbondingResponses) + } else { + suite.Error(err) + suite.Nil(res) + } + }) + } +} + +func (suite *KeeperTestSuite) TestGRPCQueryPoolParameters() { + app, ctx, queryClient := suite.app, suite.ctx, suite.queryClient + bondDenom := sdk.DefaultBondDenom + + // Query pool + res, err := queryClient.Pool(gocontext.Background(), &types.QueryPoolRequest{}) + suite.NoError(err) + bondedPool := app.StakingKeeper.GetBondedPool(ctx) + notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx) + suite.Equal(app.BankKeeper.GetBalance(ctx, notBondedPool.GetAddress(), bondDenom).Amount, res.Pool.NotBondedTokens) + suite.Equal(app.BankKeeper.GetBalance(ctx, bondedPool.GetAddress(), bondDenom).Amount, res.Pool.BondedTokens) + + // Query Params + resp, err := queryClient.Params(gocontext.Background(), &types.QueryParamsRequest{}) + suite.NoError(err) + suite.Equal(app.StakingKeeper.GetParams(ctx), resp.Params) +} + +func (suite *KeeperTestSuite) TestGRPCQueryHistoricalInfo() { + app, ctx, queryClient := suite.app, suite.ctx, suite.queryClient + + hi, found := app.StakingKeeper.GetHistoricalInfo(ctx, 5) + suite.True(found) + + var req *types.QueryHistoricalInfoRequest + testCases := []struct { + msg string + malleate func() + expPass bool + }{ + {"empty request", + func() { + req = &types.QueryHistoricalInfoRequest{} + }, + false, + }, + {"invalid request with negative height", + func() { + req = &types.QueryHistoricalInfoRequest{Height: -1} + }, + false, + }, + {"valid request with old height", + func() { + req = &types.QueryHistoricalInfoRequest{Height: 4} + }, + false, + }, + {"valid request with current height", + func() { + req = &types.QueryHistoricalInfoRequest{Height: 5} + }, + true, + }, + } + + for _, tc := range testCases { + suite.Run(fmt.Sprintf("Case %s", tc.msg), func() { + tc.malleate() + res, err := queryClient.HistoricalInfo(gocontext.Background(), req) + if tc.expPass { + suite.NoError(err) + suite.NotNil(res) + suite.Equal(&hi, res.Hist) + } else { + suite.Error(err) + suite.Nil(res) + } + }) + } +} + +func (suite *KeeperTestSuite) TestGRPCQueryRedelegation() { + app, ctx, queryClient, addrs, vals := suite.app, suite.ctx, suite.queryClient, suite.addrs, suite.vals + + addrAcc, addrAcc1 := addrs[0], addrs[1] + valAddrs := simapp.ConvertAddrsToValAddrs(addrs) + val1, val2, val3, val4 := vals[0], vals[1], valAddrs[3], valAddrs[4] + delAmount := sdk.TokensFromConsensusPower(1) + _, err := app.StakingKeeper.Delegate(ctx, addrAcc1, delAmount, sdk.Unbonded, val1, true) + suite.NoError(err) + _ = app.StakingKeeper.ApplyAndReturnValidatorSetUpdates(ctx) + + rdAmount := sdk.TokensFromConsensusPower(1) + _, err = app.StakingKeeper.BeginRedelegation(ctx, addrAcc1, val1.GetOperator(), val2.GetOperator(), rdAmount.ToDec()) + suite.NoError(err) + app.StakingKeeper.ApplyAndReturnValidatorSetUpdates(ctx) + + redel, found := app.StakingKeeper.GetRedelegation(ctx, addrAcc1, val1.OperatorAddress, val2.OperatorAddress) + suite.True(found) + + var req *types.QueryRedelegationsRequest + testCases := []struct { + msg string + malleate func() + expPass bool + expErr bool + }{ + {"request redelegations for non existant addr", + func() { + req = &types.QueryRedelegationsRequest{DelegatorAddr: addrAcc} + }, + false, + false, + }, + {"request redelegations with non existent pairs", + func() { + req = &types.QueryRedelegationsRequest{DelegatorAddr: addrAcc, SrcValidatorAddr: val3, + DstValidatorAddr: val4} + }, + false, + true, + }, + {"request redelegations with delegatoraddr, sourceValAddr, destValAddr", + func() { + req = &types.QueryRedelegationsRequest{ + DelegatorAddr: addrAcc1, SrcValidatorAddr: val1.OperatorAddress, + DstValidatorAddr: val2.OperatorAddress, Req: &query.PageRequest{}} + }, + true, + false, + }, + {"request redelegations with delegatoraddr and sourceValAddr", + func() { + req = &types.QueryRedelegationsRequest{ + DelegatorAddr: addrAcc1, SrcValidatorAddr: val1.OperatorAddress, + Req: &query.PageRequest{}} + }, + true, + false, + }, + {"query redelegations with sourceValAddr only", + func() { + req = &types.QueryRedelegationsRequest{ + SrcValidatorAddr: val1.GetOperator(), + Req: &query.PageRequest{Limit: 1, CountTotal: true}} + }, + true, + false, + }, + } + + for _, tc := range testCases { + suite.Run(fmt.Sprintf("Case %s", tc.msg), func() { + tc.malleate() + res, err := queryClient.Redelegations(gocontext.Background(), req) + if tc.expPass && !tc.expErr { + suite.NoError(err) + suite.Len(res.RedelegationResponses, len(redel.Entries)) + suite.Equal(redel.DelegatorAddress, res.RedelegationResponses[0].Redelegation.DelegatorAddress) + suite.Equal(redel.ValidatorSrcAddress, res.RedelegationResponses[0].Redelegation.ValidatorSrcAddress) + suite.Equal(redel.ValidatorDstAddress, res.RedelegationResponses[0].Redelegation.ValidatorDstAddress) + suite.Len(redel.Entries, len(res.RedelegationResponses[0].Entries)) + } else if !tc.expPass && !tc.expErr { + suite.NoError(err) + suite.Nil(res.RedelegationResponses) + } else { + suite.Error(err) + suite.Nil(res) + } + }) + } +} + +func (suite *KeeperTestSuite) TestGRPCQueryValidatorUnbondingDelegations() { + app, ctx, queryClient, addrs, vals := suite.app, suite.ctx, suite.queryClient, suite.addrs, suite.vals + addrAcc1, _ := addrs[0], addrs[1] + val1 := vals[0] + + // undelegate + undelAmount := sdk.TokensFromConsensusPower(2) + _, err := app.StakingKeeper.Undelegate(ctx, addrAcc1, val1.GetOperator(), undelAmount.ToDec()) + suite.NoError(err) + app.StakingKeeper.ApplyAndReturnValidatorSetUpdates(ctx) + + var req *types.QueryValidatorUnbondingDelegationsRequest + testCases := []struct { + msg string + malleate func() + expPass bool + }{ + {"empty request", + func() { + req = &types.QueryValidatorUnbondingDelegationsRequest{} + }, + false, + }, + {"valid request", + func() { + req = &types.QueryValidatorUnbondingDelegationsRequest{ + ValidatorAddr: val1.GetOperator(), + Req: &query.PageRequest{Limit: 1, CountTotal: true}} + }, + true, + }, + } + + for _, tc := range testCases { + suite.Run(fmt.Sprintf("Case %s", tc.msg), func() { + tc.malleate() + res, err := queryClient.ValidatorUnbondingDelegations(gocontext.Background(), req) + if tc.expPass { + suite.NoError(err) + suite.Equal(uint64(1), res.Res.Total) + suite.Equal(1, len(res.UnbondingResponses)) + } else { + suite.Error(err) + suite.Nil(res) + } + }) + } +} + +func createValidators(ctx sdk.Context, app *simapp.SimApp, powers []int64) ([]sdk.AccAddress, []sdk.ValAddress, []types.Validator) { + addrs := simapp.AddTestAddrsIncremental(app, ctx, 5, sdk.NewInt(300000000)) + valAddrs := simapp.ConvertAddrsToValAddrs(addrs) + pks := simapp.CreateTestPubKeys(5) + + appCodec, _ := simapp.MakeCodecs() + app.StakingKeeper = keeper.NewKeeper( + appCodec, + app.GetKey(types.StoreKey), + app.AccountKeeper, + app.BankKeeper, + app.GetSubspace(types.ModuleName), + ) + + val1 := types.NewValidator(valAddrs[0], pks[0], types.Description{}) + val2 := types.NewValidator(valAddrs[1], pks[1], types.Description{}) + vals := []types.Validator{val1, val2} + + app.StakingKeeper.SetValidator(ctx, val1) + app.StakingKeeper.SetValidator(ctx, val2) + app.StakingKeeper.SetValidatorByConsAddr(ctx, val1) + app.StakingKeeper.SetValidatorByConsAddr(ctx, val2) + app.StakingKeeper.SetNewValidatorByPowerIndex(ctx, val1) + app.StakingKeeper.SetNewValidatorByPowerIndex(ctx, val2) + + _, _ = app.StakingKeeper.Delegate(ctx, addrs[0], sdk.TokensFromConsensusPower(powers[0]), sdk.Unbonded, val1, true) + _, _ = app.StakingKeeper.Delegate(ctx, addrs[1], sdk.TokensFromConsensusPower(powers[1]), sdk.Unbonded, val2, true) + _, _ = app.StakingKeeper.Delegate(ctx, addrs[0], sdk.TokensFromConsensusPower(powers[2]), sdk.Unbonded, val2, true) + app.StakingKeeper.ApplyAndReturnValidatorSetUpdates(ctx) + + return addrs, valAddrs, vals +} diff --git a/x/staking/keeper/keeper_test.go b/x/staking/keeper/keeper_test.go index 10fd2253b716..b3764d0776d8 100644 --- a/x/staking/keeper/keeper_test.go +++ b/x/staking/keeper/keeper_test.go @@ -4,13 +4,48 @@ import ( "testing" "github.com/stretchr/testify/require" + "github.com/stretchr/testify/suite" abci "github.com/tendermint/tendermint/abci/types" + "github.com/cosmos/cosmos-sdk/baseapp" "github.com/cosmos/cosmos-sdk/simapp" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/staking/keeper" "github.com/cosmos/cosmos-sdk/x/staking/types" ) +type KeeperTestSuite struct { + suite.Suite + + app *simapp.SimApp + ctx sdk.Context + addrs []sdk.AccAddress + vals []types.Validator + queryClient types.QueryClient +} + +func (suite *KeeperTestSuite) SetupTest() { + app := simapp.Setup(false) + ctx := app.BaseApp.NewContext(false, abci.Header{}) + + querier := keeper.Querier{Keeper: app.StakingKeeper} + + queryHelper := baseapp.NewQueryServerTestHelper(ctx, app.InterfaceRegistry()) + types.RegisterQueryServer(queryHelper, querier) + queryClient := types.NewQueryClient(queryHelper) + + addrs, _, validators := createValidators(ctx, app, []int64{9, 8, 7}) + header := abci.Header{ + ChainID: "HelloChain", + Height: 5, + } + + hi := types.NewHistoricalInfo(header, validators) + app.StakingKeeper.SetHistoricalInfo(ctx, 5, hi) + + suite.app, suite.ctx, suite.queryClient, suite.addrs, suite.vals = app, ctx, queryClient, addrs, validators +} func TestParams(t *testing.T) { app := simapp.Setup(false) ctx := app.BaseApp.NewContext(false, abci.Header{}) @@ -27,3 +62,7 @@ func TestParams(t *testing.T) { resParams = app.StakingKeeper.GetParams(ctx) require.True(t, expParams.Equal(resParams)) } + +func TestKeeperTestSuite(t *testing.T) { + suite.Run(t, new(KeeperTestSuite)) +} diff --git a/x/staking/keeper/querier.go b/x/staking/keeper/querier.go index 31c6b986b7b0..309ba0fa0273 100644 --- a/x/staking/keeper/querier.go +++ b/x/staking/keeper/querier.go @@ -135,7 +135,7 @@ func queryValidatorDelegations(ctx sdk.Context, req abci.RequestQuery, k Keeper) delegations = delegations[start:end] } - delegationResps, err := delegationsToDelegationResponses(ctx, k, delegations) + delegationResps, err := DelegationsToDelegationResponses(ctx, k, delegations) if err != nil { return nil, err } @@ -189,7 +189,7 @@ func queryDelegatorDelegations(ctx sdk.Context, req abci.RequestQuery, k Keeper) } delegations := k.GetAllDelegatorDelegations(ctx, params.DelegatorAddr) - delegationResps, err := delegationsToDelegationResponses(ctx, k, delegations) + delegationResps, err := DelegationsToDelegationResponses(ctx, k, delegations) if err != nil { return nil, err @@ -252,7 +252,7 @@ func queryDelegatorValidators(ctx sdk.Context, req abci.RequestQuery, k Keeper) } func queryDelegatorValidator(ctx sdk.Context, req abci.RequestQuery, k Keeper) ([]byte, error) { - var params types.QueryBondsParams + var params types.QueryDelegatorValidatorRequest err := types.ModuleCdc.UnmarshalJSON(req.Data, ¶ms) if err != nil { @@ -273,7 +273,7 @@ func queryDelegatorValidator(ctx sdk.Context, req abci.RequestQuery, k Keeper) ( } func queryDelegation(ctx sdk.Context, req abci.RequestQuery, k Keeper) ([]byte, error) { - var params types.QueryBondsParams + var params types.QueryDelegatorValidatorRequest err := types.ModuleCdc.UnmarshalJSON(req.Data, ¶ms) if err != nil { @@ -285,7 +285,7 @@ func queryDelegation(ctx sdk.Context, req abci.RequestQuery, k Keeper) ([]byte, return nil, types.ErrNoDelegation } - delegationResp, err := delegationToDelegationResponse(ctx, k, delegation) + delegationResp, err := DelegationToDelegationResponse(ctx, k, delegation) if err != nil { return nil, err } @@ -299,7 +299,7 @@ func queryDelegation(ctx sdk.Context, req abci.RequestQuery, k Keeper) ([]byte, } func queryUnbondingDelegation(ctx sdk.Context, req abci.RequestQuery, k Keeper) ([]byte, error) { - var params types.QueryBondsParams + var params types.QueryDelegatorValidatorRequest err := types.ModuleCdc.UnmarshalJSON(req.Data, ¶ms) if err != nil { @@ -343,7 +343,7 @@ func queryRedelegations(ctx sdk.Context, req abci.RequestQuery, k Keeper) ([]byt redels = k.GetAllRedelegations(ctx, params.DelegatorAddr, params.SrcValidatorAddr, params.DstValidatorAddr) } - redelResponses, err := redelegationsToRedelegationResponses(ctx, k, redels) + redelResponses, err := RedelegationsToRedelegationResponses(ctx, k, redels) if err != nil { return nil, err } @@ -361,7 +361,7 @@ func queryRedelegations(ctx sdk.Context, req abci.RequestQuery, k Keeper) ([]byt } func queryHistoricalInfo(ctx sdk.Context, req abci.RequestQuery, k Keeper) ([]byte, error) { - var params types.QueryHistoricalInfoParams + var params types.QueryHistoricalInfoRequest err := types.ModuleCdc.UnmarshalJSON(req.Data, ¶ms) if err != nil { @@ -417,7 +417,7 @@ func queryParameters(ctx sdk.Context, k Keeper) ([]byte, error) { //______________________________________________________ // util -func delegationToDelegationResponse(ctx sdk.Context, k Keeper, del types.Delegation) (types.DelegationResponse, error) { +func DelegationToDelegationResponse(ctx sdk.Context, k Keeper, del types.Delegation) (types.DelegationResponse, error) { val, found := k.GetValidator(ctx, del.ValidatorAddress) if !found { return types.DelegationResponse{}, types.ErrNoValidatorFound @@ -431,13 +431,13 @@ func delegationToDelegationResponse(ctx sdk.Context, k Keeper, del types.Delegat ), nil } -func delegationsToDelegationResponses( +func DelegationsToDelegationResponses( ctx sdk.Context, k Keeper, delegations types.Delegations, ) (types.DelegationResponses, error) { resp := make(types.DelegationResponses, len(delegations)) for i, del := range delegations { - delResp, err := delegationToDelegationResponse(ctx, k, del) + delResp, err := DelegationToDelegationResponse(ctx, k, del) if err != nil { return nil, err } @@ -448,7 +448,7 @@ func delegationsToDelegationResponses( return resp, nil } -func redelegationsToRedelegationResponses( +func RedelegationsToRedelegationResponses( ctx sdk.Context, k Keeper, redels types.Redelegations, ) (types.RedelegationResponses, error) { resp := make(types.RedelegationResponses, len(redels)) diff --git a/x/staking/keeper/querier_test.go b/x/staking/keeper/querier_test.go index acd76d8874f8..63cce0a2b8e5 100644 --- a/x/staking/keeper/querier_test.go +++ b/x/staking/keeper/querier_test.go @@ -94,7 +94,7 @@ func TestNewQuerier(t *testing.T) { _, err = querier(ctx, []string{"redelegations"}, query) require.NoError(t, err) - queryHisParams := types.NewQueryHistoricalInfoParams(5) + queryHisParams := types.QueryHistoricalInfoRequest{Height: 5} bz, errRes = cdc.MarshalJSON(queryHisParams) require.NoError(t, errRes) @@ -254,7 +254,7 @@ func TestQueryDelegation(t *testing.T) { require.Error(t, err) // Query bonded validator - queryBondParams := types.NewQueryBondsParams(addrAcc2, addrVal1) + queryBondParams := types.QueryDelegatorValidatorRequest{DelegatorAddr: addrAcc2, ValidatorAddr: addrVal1} bz, errRes = cdc.MarshalJSON(queryBondParams) require.NoError(t, errRes) @@ -295,8 +295,8 @@ func TestQueryDelegation(t *testing.T) { errRes = cdc.UnmarshalJSON(res, &delegationRes) require.NoError(t, errRes) - require.Equal(t, delegation.ValidatorAddress, delegationRes.ValidatorAddress) - require.Equal(t, delegation.DelegatorAddress, delegationRes.DelegatorAddress) + require.Equal(t, delegation.ValidatorAddress, delegationRes.Delegation.ValidatorAddress) + require.Equal(t, delegation.DelegatorAddress, delegationRes.Delegation.DelegatorAddress) require.Equal(t, sdk.NewCoin(sdk.DefaultBondDenom, delegation.Shares.TruncateInt()), delegationRes.Balance) // Query Delegator Delegations @@ -312,8 +312,8 @@ func TestQueryDelegation(t *testing.T) { errRes = cdc.UnmarshalJSON(res, &delegatorDelegations) require.NoError(t, errRes) require.Len(t, delegatorDelegations, 1) - require.Equal(t, delegation.ValidatorAddress, delegatorDelegations[0].ValidatorAddress) - require.Equal(t, delegation.DelegatorAddress, delegatorDelegations[0].DelegatorAddress) + require.Equal(t, delegation.ValidatorAddress, delegatorDelegations[0].Delegation.ValidatorAddress) + require.Equal(t, delegation.DelegatorAddress, delegatorDelegations[0].Delegation.DelegatorAddress) require.Equal(t, sdk.NewCoin(sdk.DefaultBondDenom, delegation.Shares.TruncateInt()), delegatorDelegations[0].Balance) // error unknown request @@ -338,8 +338,8 @@ func TestQueryDelegation(t *testing.T) { errRes = cdc.UnmarshalJSON(res, &delegationsRes) require.NoError(t, errRes) require.Len(t, delegatorDelegations, 1) - require.Equal(t, delegation.ValidatorAddress, delegationsRes[0].ValidatorAddress) - require.Equal(t, delegation.DelegatorAddress, delegationsRes[0].DelegatorAddress) + require.Equal(t, delegation.ValidatorAddress, delegationsRes[0].Delegation.ValidatorAddress) + require.Equal(t, delegation.DelegatorAddress, delegationsRes[0].Delegation.DelegatorAddress) require.Equal(t, sdk.NewCoin(sdk.DefaultBondDenom, delegation.Shares.TruncateInt()), delegationsRes[0].Balance) // Query unbonding delegation @@ -347,7 +347,7 @@ func TestQueryDelegation(t *testing.T) { _, err = app.StakingKeeper.Undelegate(ctx, addrAcc2, val1.OperatorAddress, unbondingTokens.ToDec()) require.NoError(t, err) - queryBondParams = types.NewQueryBondsParams(addrAcc2, addrVal1) + queryBondParams = types.QueryDelegatorValidatorRequest{DelegatorAddr: addrAcc2, ValidatorAddr: addrVal1} bz, errRes = cdc.MarshalJSON(queryBondParams) require.NoError(t, errRes) @@ -374,7 +374,7 @@ func TestQueryDelegation(t *testing.T) { _, err = querier(ctx, []string{types.QueryUnbondingDelegation}, query) require.Error(t, err) - // Query Delegator Delegations + // Query Delegator Unbonding Delegations query = abci.RequestQuery{ Path: "/custom/staking/delegatorUnbondingDelegations", @@ -418,9 +418,9 @@ func TestQueryDelegation(t *testing.T) { errRes = cdc.UnmarshalJSON(res, &redelRes) require.NoError(t, errRes) require.Len(t, redelRes, 1) - require.Equal(t, redel.DelegatorAddress, redelRes[0].DelegatorAddress) - require.Equal(t, redel.ValidatorSrcAddress, redelRes[0].ValidatorSrcAddress) - require.Equal(t, redel.ValidatorDstAddress, redelRes[0].ValidatorDstAddress) + require.Equal(t, redel.DelegatorAddress, redelRes[0].Redelegation.DelegatorAddress) + require.Equal(t, redel.ValidatorSrcAddress, redelRes[0].Redelegation.ValidatorSrcAddress) + require.Equal(t, redel.ValidatorDstAddress, redelRes[0].Redelegation.ValidatorDstAddress) require.Len(t, redel.Entries, len(redelRes[0].Entries)) } @@ -574,9 +574,9 @@ func TestQueryRedelegations(t *testing.T) { errRes = cdc.UnmarshalJSON(res, &redelRes) require.NoError(t, errRes) require.Len(t, redelRes, 1) - require.Equal(t, redel.DelegatorAddress, redelRes[0].DelegatorAddress) - require.Equal(t, redel.ValidatorSrcAddress, redelRes[0].ValidatorSrcAddress) - require.Equal(t, redel.ValidatorDstAddress, redelRes[0].ValidatorDstAddress) + require.Equal(t, redel.DelegatorAddress, redelRes[0].Redelegation.DelegatorAddress) + require.Equal(t, redel.ValidatorSrcAddress, redelRes[0].Redelegation.ValidatorSrcAddress) + require.Equal(t, redel.ValidatorDstAddress, redelRes[0].Redelegation.ValidatorDstAddress) require.Len(t, redel.Entries, len(redelRes[0].Entries)) // validator redelegations @@ -595,9 +595,9 @@ func TestQueryRedelegations(t *testing.T) { errRes = cdc.UnmarshalJSON(res, &redelRes) require.NoError(t, errRes) require.Len(t, redelRes, 1) - require.Equal(t, redel.DelegatorAddress, redelRes[0].DelegatorAddress) - require.Equal(t, redel.ValidatorSrcAddress, redelRes[0].ValidatorSrcAddress) - require.Equal(t, redel.ValidatorDstAddress, redelRes[0].ValidatorDstAddress) + require.Equal(t, redel.DelegatorAddress, redelRes[0].Redelegation.DelegatorAddress) + require.Equal(t, redel.ValidatorSrcAddress, redelRes[0].Redelegation.ValidatorSrcAddress) + require.Equal(t, redel.ValidatorDstAddress, redelRes[0].Redelegation.ValidatorDstAddress) require.Len(t, redel.Entries, len(redelRes[0].Entries)) } @@ -631,7 +631,7 @@ func TestQueryUnbondingDelegation(t *testing.T) { // // found: query unbonding delegation by delegator and validator // - queryValidatorParams := types.NewQueryBondsParams(addrAcc1, val1.GetOperator()) + queryValidatorParams := types.QueryDelegatorValidatorRequest{DelegatorAddr: addrAcc1, ValidatorAddr: val1.GetOperator()} bz, errRes := cdc.MarshalJSON(queryValidatorParams) require.NoError(t, errRes) query := abci.RequestQuery{ @@ -650,7 +650,7 @@ func TestQueryUnbondingDelegation(t *testing.T) { // // not found: query unbonding delegation by delegator and validator // - queryValidatorParams = types.NewQueryBondsParams(addrAcc2, val1.GetOperator()) + queryValidatorParams = types.QueryDelegatorValidatorRequest{DelegatorAddr: addrAcc2, ValidatorAddr: val1.GetOperator()} bz, errRes = cdc.MarshalJSON(queryValidatorParams) require.NoError(t, errRes) query = abci.RequestQuery{ @@ -718,7 +718,7 @@ func TestQueryHistoricalInfo(t *testing.T) { hi := types.NewHistoricalInfo(header, vals) app.StakingKeeper.SetHistoricalInfo(ctx, 5, hi) - queryHistoricalParams := types.NewQueryHistoricalInfoParams(4) + queryHistoricalParams := types.QueryHistoricalInfoRequest{Height: 4} bz, errRes := cdc.MarshalJSON(queryHistoricalParams) require.NoError(t, errRes) query := abci.RequestQuery{ @@ -729,7 +729,7 @@ func TestQueryHistoricalInfo(t *testing.T) { require.Error(t, err, "Invalid query passed") require.Nil(t, res, "Invalid query returned non-nil result") - queryHistoricalParams = types.NewQueryHistoricalInfoParams(5) + queryHistoricalParams = types.QueryHistoricalInfoRequest{Height: 5} bz, errRes = cdc.MarshalJSON(queryHistoricalParams) require.NoError(t, errRes) query.Data = bz diff --git a/x/staking/types/delegation.go b/x/staking/types/delegation.go index 3ed9917cb664..40dfc368cbfb 100644 --- a/x/staking/types/delegation.go +++ b/x/staking/types/delegation.go @@ -278,13 +278,6 @@ func (d Redelegations) String() (out string) { // ---------------------------------------------------------------------------- // Client Types -// DelegationResponse is equivalent to Delegation except that it contains a balance -// in addition to shares which is more suitable for client responses. -type DelegationResponse struct { - Delegation - Balance sdk.Coin `json:"balance" yaml:"balance"` -} - // NewDelegationResp creates a new DelegationResponse instance func NewDelegationResp( delegatorAddr sdk.AccAddress, validatorAddr sdk.ValAddress, shares sdk.Dec, balance sdk.Coin, @@ -326,14 +319,6 @@ func (d DelegationResponses) String() (out string) { return strings.TrimSpace(out) } -// RedelegationResponse is equivalent to a Redelegation except that its entries -// contain a balance in addition to shares which is more suitable for client -// responses. -type RedelegationResponse struct { - Redelegation - Entries []RedelegationEntryResponse `json:"entries" yaml:"entries"` -} - // NewRedelegationResponse crates a new RedelegationEntryResponse instance. func NewRedelegationResponse( delegatorAddr sdk.AccAddress, validatorSrc, validatorDst sdk.ValAddress, entries []RedelegationEntryResponse, @@ -348,14 +333,6 @@ func NewRedelegationResponse( } } -// RedelegationEntryResponse is equivalent to a RedelegationEntry except that it -// contains a balance in addition to shares which is more suitable for client -// responses. -type RedelegationEntryResponse struct { - RedelegationEntry - Balance sdk.Int `json:"balance"` -} - // NewRedelegationEntryResponse creates a new RedelegationEntryResponse instance. func NewRedelegationEntryResponse( creationHeight int64, completionTime time.Time, sharesDst sdk.Dec, initialBalance, balance sdk.Int) RedelegationEntryResponse { @@ -365,32 +342,6 @@ func NewRedelegationEntryResponse( } } -// String implements the Stringer interface for RedelegationResp. -func (r RedelegationResponse) String() string { - out := fmt.Sprintf(`Redelegations between: - Delegator: %s - Source Validator: %s - Destination Validator: %s - Entries: -`, - r.DelegatorAddress, r.ValidatorSrcAddress, r.ValidatorDstAddress, - ) - - for i, entry := range r.Entries { - out += fmt.Sprintf(` Redelegation Entry #%d: - Creation height: %v - Min time to unbond (unix): %v - Initial Balance: %s - Shares: %s - Balance: %s -`, - i, entry.CreationHeight, entry.CompletionTime, entry.InitialBalance, entry.SharesDst, entry.Balance, - ) - } - - return strings.TrimRight(out, "\n") -} - type redelegationRespAlias RedelegationResponse // MarshalJSON implements the json.Marshaler interface. This is so we can diff --git a/x/staking/types/pool.go b/x/staking/types/pool.go index c19bf59a41ad..c71d1684f9aa 100644 --- a/x/staking/types/pool.go +++ b/x/staking/types/pool.go @@ -1,8 +1,6 @@ package types import ( - "fmt" - sdk "github.com/cosmos/cosmos-sdk/types" ) @@ -16,12 +14,6 @@ const ( BondedPoolName = "bonded_tokens_pool" ) -// Pool - tracking bonded and not-bonded token supply of the bond denomination -type Pool struct { - NotBondedTokens sdk.Int `json:"not_bonded_tokens" yaml:"not_bonded_tokens"` // tokens which are not bonded to a validator (unbonded or unbonding) - BondedTokens sdk.Int `json:"bonded_tokens" yaml:"bonded_tokens"` // tokens which are currently bonded to a validator -} - // NewPool creates a new Pool instance used for queries func NewPool(notBonded, bonded sdk.Int) Pool { return Pool{ @@ -29,11 +21,3 @@ func NewPool(notBonded, bonded sdk.Int) Pool { BondedTokens: bonded, } } - -// String returns a human readable string representation of a pool. -func (p Pool) String() string { - return fmt.Sprintf(`Pool: - Not Bonded Tokens: %s - Bonded Tokens: %s`, p.NotBondedTokens, - p.BondedTokens) -} diff --git a/x/staking/types/querier.go b/x/staking/types/querier.go index dfde91403169..08fefae0736a 100644 --- a/x/staking/types/querier.go +++ b/x/staking/types/querier.go @@ -41,7 +41,6 @@ func NewQueryDelegatorParams(delegatorAddr sdk.AccAddress) QueryDelegatorParams // - 'custom/staking/validator' // - 'custom/staking/validatorDelegations' // - 'custom/staking/validatorUnbondingDelegations' -// - 'custom/staking/validatorRedelegations' type QueryValidatorParams struct { ValidatorAddr sdk.ValAddress Page, Limit int @@ -55,22 +54,6 @@ func NewQueryValidatorParams(validatorAddr sdk.ValAddress, page, limit int) Quer } } -// defines the params for the following queries: -// - 'custom/staking/delegation' -// - 'custom/staking/unbondingDelegation' -// - 'custom/staking/delegatorValidator' -type QueryBondsParams struct { - DelegatorAddr sdk.AccAddress - ValidatorAddr sdk.ValAddress -} - -func NewQueryBondsParams(delegatorAddr sdk.AccAddress, validatorAddr sdk.ValAddress) QueryBondsParams { - return QueryBondsParams{ - DelegatorAddr: delegatorAddr, - ValidatorAddr: validatorAddr, - } -} - // defines the params for the following queries: // - 'custom/staking/redelegation' type QueryRedelegationParams struct { @@ -97,14 +80,3 @@ type QueryValidatorsParams struct { func NewQueryValidatorsParams(page, limit int, status string) QueryValidatorsParams { return QueryValidatorsParams{page, limit, status} } - -// QueryHistoricalInfoParams defines the params for the following queries: -// - 'custom/staking/historicalInfo' -type QueryHistoricalInfoParams struct { - Height int64 -} - -// NewQueryHistoricalInfoParams creates a new QueryHistoricalInfoParams instance -func NewQueryHistoricalInfoParams(height int64) QueryHistoricalInfoParams { - return QueryHistoricalInfoParams{height} -} diff --git a/x/staking/types/query.pb.go b/x/staking/types/query.pb.go new file mode 100644 index 000000000000..fcb7a04618fe --- /dev/null +++ b/x/staking/types/query.pb.go @@ -0,0 +1,6847 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: cosmos/staking/query.proto + +package types + +import ( + context "context" + fmt "fmt" + github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" + query "github.com/cosmos/cosmos-sdk/types/query" + _ "github.com/gogo/protobuf/gogoproto" + grpc1 "github.com/gogo/protobuf/grpc" + proto "github.com/gogo/protobuf/proto" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +// QueryValidatorsRequest is request type for Query/Validators RPC method +type QueryValidatorsRequest struct { + Status string `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"` + Req *query.PageRequest `protobuf:"bytes,2,opt,name=req,proto3" json:"req,omitempty"` +} + +func (m *QueryValidatorsRequest) Reset() { *m = QueryValidatorsRequest{} } +func (m *QueryValidatorsRequest) String() string { return proto.CompactTextString(m) } +func (*QueryValidatorsRequest) ProtoMessage() {} +func (*QueryValidatorsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_802d43a0c79dce0e, []int{0} +} +func (m *QueryValidatorsRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryValidatorsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryValidatorsRequest.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 *QueryValidatorsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryValidatorsRequest.Merge(m, src) +} +func (m *QueryValidatorsRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryValidatorsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryValidatorsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryValidatorsRequest proto.InternalMessageInfo + +func (m *QueryValidatorsRequest) GetStatus() string { + if m != nil { + return m.Status + } + return "" +} + +func (m *QueryValidatorsRequest) GetReq() *query.PageRequest { + if m != nil { + return m.Req + } + return nil +} + +// QueryValidatorsResponse is response type for the Query/Validators RPC method +type QueryValidatorsResponse struct { + Validators []Validator `protobuf:"bytes,1,rep,name=validators,proto3" json:"validators"` + Res *query.PageResponse `protobuf:"bytes,2,opt,name=res,proto3" json:"res,omitempty"` +} + +func (m *QueryValidatorsResponse) Reset() { *m = QueryValidatorsResponse{} } +func (m *QueryValidatorsResponse) String() string { return proto.CompactTextString(m) } +func (*QueryValidatorsResponse) ProtoMessage() {} +func (*QueryValidatorsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_802d43a0c79dce0e, []int{1} +} +func (m *QueryValidatorsResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryValidatorsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryValidatorsResponse.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 *QueryValidatorsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryValidatorsResponse.Merge(m, src) +} +func (m *QueryValidatorsResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryValidatorsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryValidatorsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryValidatorsResponse proto.InternalMessageInfo + +func (m *QueryValidatorsResponse) GetValidators() []Validator { + if m != nil { + return m.Validators + } + return nil +} + +func (m *QueryValidatorsResponse) GetRes() *query.PageResponse { + if m != nil { + return m.Res + } + return nil +} + +// QueryValidatorRequest is response type for the Query/Validator RPC method +type QueryValidatorRequest struct { + ValidatorAddr github_com_cosmos_cosmos_sdk_types.ValAddress `protobuf:"bytes,1,opt,name=validator_addr,json=validatorAddr,proto3,casttype=github.com/cosmos/cosmos-sdk/types.ValAddress" json:"validator_addr,omitempty"` +} + +func (m *QueryValidatorRequest) Reset() { *m = QueryValidatorRequest{} } +func (m *QueryValidatorRequest) String() string { return proto.CompactTextString(m) } +func (*QueryValidatorRequest) ProtoMessage() {} +func (*QueryValidatorRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_802d43a0c79dce0e, []int{2} +} +func (m *QueryValidatorRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryValidatorRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryValidatorRequest.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 *QueryValidatorRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryValidatorRequest.Merge(m, src) +} +func (m *QueryValidatorRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryValidatorRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryValidatorRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryValidatorRequest proto.InternalMessageInfo + +func (m *QueryValidatorRequest) GetValidatorAddr() github_com_cosmos_cosmos_sdk_types.ValAddress { + if m != nil { + return m.ValidatorAddr + } + return nil +} + +// QueryValidatorResponse is response type for the Query/Validator RPC method +type QueryValidatorResponse struct { + Validator Validator `protobuf:"bytes,1,opt,name=validator,proto3" json:"validator"` +} + +func (m *QueryValidatorResponse) Reset() { *m = QueryValidatorResponse{} } +func (m *QueryValidatorResponse) String() string { return proto.CompactTextString(m) } +func (*QueryValidatorResponse) ProtoMessage() {} +func (*QueryValidatorResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_802d43a0c79dce0e, []int{3} +} +func (m *QueryValidatorResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryValidatorResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryValidatorResponse.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 *QueryValidatorResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryValidatorResponse.Merge(m, src) +} +func (m *QueryValidatorResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryValidatorResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryValidatorResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryValidatorResponse proto.InternalMessageInfo + +func (m *QueryValidatorResponse) GetValidator() Validator { + if m != nil { + return m.Validator + } + return Validator{} +} + +// QueryValidatorDelegationsRequest is request type for the Query/ValidatorDelegations RPC method +type QueryValidatorDelegationsRequest struct { + ValidatorAddr github_com_cosmos_cosmos_sdk_types.ValAddress `protobuf:"bytes,1,opt,name=validator_addr,json=validatorAddr,proto3,casttype=github.com/cosmos/cosmos-sdk/types.ValAddress" json:"validator_addr,omitempty"` + Req *query.PageRequest `protobuf:"bytes,2,opt,name=req,proto3" json:"req,omitempty"` +} + +func (m *QueryValidatorDelegationsRequest) Reset() { *m = QueryValidatorDelegationsRequest{} } +func (m *QueryValidatorDelegationsRequest) String() string { return proto.CompactTextString(m) } +func (*QueryValidatorDelegationsRequest) ProtoMessage() {} +func (*QueryValidatorDelegationsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_802d43a0c79dce0e, []int{4} +} +func (m *QueryValidatorDelegationsRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryValidatorDelegationsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryValidatorDelegationsRequest.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 *QueryValidatorDelegationsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryValidatorDelegationsRequest.Merge(m, src) +} +func (m *QueryValidatorDelegationsRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryValidatorDelegationsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryValidatorDelegationsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryValidatorDelegationsRequest proto.InternalMessageInfo + +func (m *QueryValidatorDelegationsRequest) GetValidatorAddr() github_com_cosmos_cosmos_sdk_types.ValAddress { + if m != nil { + return m.ValidatorAddr + } + return nil +} + +func (m *QueryValidatorDelegationsRequest) GetReq() *query.PageRequest { + if m != nil { + return m.Req + } + return nil +} + +// QueryValidatorDelegationsRequest is response type for the Query/ValidatorDelegations RPC method +type QueryValidatorDelegationsResponse struct { + DelegationResponses DelegationResponses `protobuf:"bytes,1,rep,name=delegation_responses,json=delegationResponses,proto3,castrepeated=DelegationResponses" json:"delegation_responses"` + Res *query.PageResponse `protobuf:"bytes,2,opt,name=res,proto3" json:"res,omitempty"` +} + +func (m *QueryValidatorDelegationsResponse) Reset() { *m = QueryValidatorDelegationsResponse{} } +func (m *QueryValidatorDelegationsResponse) String() string { return proto.CompactTextString(m) } +func (*QueryValidatorDelegationsResponse) ProtoMessage() {} +func (*QueryValidatorDelegationsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_802d43a0c79dce0e, []int{5} +} +func (m *QueryValidatorDelegationsResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryValidatorDelegationsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryValidatorDelegationsResponse.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 *QueryValidatorDelegationsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryValidatorDelegationsResponse.Merge(m, src) +} +func (m *QueryValidatorDelegationsResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryValidatorDelegationsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryValidatorDelegationsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryValidatorDelegationsResponse proto.InternalMessageInfo + +func (m *QueryValidatorDelegationsResponse) GetDelegationResponses() DelegationResponses { + if m != nil { + return m.DelegationResponses + } + return nil +} + +func (m *QueryValidatorDelegationsResponse) GetRes() *query.PageResponse { + if m != nil { + return m.Res + } + return nil +} + +// QueryValidatorUnbondingDelegationsRequest is required type for the Query/ValidatorUnbondingDelegations RPC method +type QueryValidatorUnbondingDelegationsRequest struct { + ValidatorAddr github_com_cosmos_cosmos_sdk_types.ValAddress `protobuf:"bytes,1,opt,name=validator_addr,json=validatorAddr,proto3,casttype=github.com/cosmos/cosmos-sdk/types.ValAddress" json:"validator_addr,omitempty"` + Req *query.PageRequest `protobuf:"bytes,2,opt,name=req,proto3" json:"req,omitempty"` +} + +func (m *QueryValidatorUnbondingDelegationsRequest) Reset() { + *m = QueryValidatorUnbondingDelegationsRequest{} +} +func (m *QueryValidatorUnbondingDelegationsRequest) String() string { + return proto.CompactTextString(m) +} +func (*QueryValidatorUnbondingDelegationsRequest) ProtoMessage() {} +func (*QueryValidatorUnbondingDelegationsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_802d43a0c79dce0e, []int{6} +} +func (m *QueryValidatorUnbondingDelegationsRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryValidatorUnbondingDelegationsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryValidatorUnbondingDelegationsRequest.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 *QueryValidatorUnbondingDelegationsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryValidatorUnbondingDelegationsRequest.Merge(m, src) +} +func (m *QueryValidatorUnbondingDelegationsRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryValidatorUnbondingDelegationsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryValidatorUnbondingDelegationsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryValidatorUnbondingDelegationsRequest proto.InternalMessageInfo + +func (m *QueryValidatorUnbondingDelegationsRequest) GetValidatorAddr() github_com_cosmos_cosmos_sdk_types.ValAddress { + if m != nil { + return m.ValidatorAddr + } + return nil +} + +func (m *QueryValidatorUnbondingDelegationsRequest) GetReq() *query.PageRequest { + if m != nil { + return m.Req + } + return nil +} + +// QueryValidatorUnbondingDelegationsResponse is response type for the Query/ValidatorUnbondingDelegations RPC method +type QueryValidatorUnbondingDelegationsResponse struct { + UnbondingResponses []UnbondingDelegation `protobuf:"bytes,1,rep,name=unbonding_responses,json=unbondingResponses,proto3" json:"unbonding_responses"` + Res *query.PageResponse `protobuf:"bytes,2,opt,name=res,proto3" json:"res,omitempty"` +} + +func (m *QueryValidatorUnbondingDelegationsResponse) Reset() { + *m = QueryValidatorUnbondingDelegationsResponse{} +} +func (m *QueryValidatorUnbondingDelegationsResponse) String() string { + return proto.CompactTextString(m) +} +func (*QueryValidatorUnbondingDelegationsResponse) ProtoMessage() {} +func (*QueryValidatorUnbondingDelegationsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_802d43a0c79dce0e, []int{7} +} +func (m *QueryValidatorUnbondingDelegationsResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryValidatorUnbondingDelegationsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryValidatorUnbondingDelegationsResponse.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 *QueryValidatorUnbondingDelegationsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryValidatorUnbondingDelegationsResponse.Merge(m, src) +} +func (m *QueryValidatorUnbondingDelegationsResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryValidatorUnbondingDelegationsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryValidatorUnbondingDelegationsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryValidatorUnbondingDelegationsResponse proto.InternalMessageInfo + +func (m *QueryValidatorUnbondingDelegationsResponse) GetUnbondingResponses() []UnbondingDelegation { + if m != nil { + return m.UnbondingResponses + } + return nil +} + +func (m *QueryValidatorUnbondingDelegationsResponse) GetRes() *query.PageResponse { + if m != nil { + return m.Res + } + return nil +} + +// QueryDelegationRequest is request type for the Query/Delegation RPC method +type QueryDelegationRequest struct { + DelegatorAddr github_com_cosmos_cosmos_sdk_types.AccAddress `protobuf:"bytes,1,opt,name=delegator_addr,json=delegatorAddr,proto3,casttype=github.com/cosmos/cosmos-sdk/types.AccAddress" json:"delegator_addr,omitempty"` + ValidatorAddr github_com_cosmos_cosmos_sdk_types.ValAddress `protobuf:"bytes,2,opt,name=validator_addr,json=validatorAddr,proto3,casttype=github.com/cosmos/cosmos-sdk/types.ValAddress" json:"validator_addr,omitempty"` +} + +func (m *QueryDelegationRequest) Reset() { *m = QueryDelegationRequest{} } +func (m *QueryDelegationRequest) String() string { return proto.CompactTextString(m) } +func (*QueryDelegationRequest) ProtoMessage() {} +func (*QueryDelegationRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_802d43a0c79dce0e, []int{8} +} +func (m *QueryDelegationRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryDelegationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryDelegationRequest.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 *QueryDelegationRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryDelegationRequest.Merge(m, src) +} +func (m *QueryDelegationRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryDelegationRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryDelegationRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryDelegationRequest proto.InternalMessageInfo + +func (m *QueryDelegationRequest) GetDelegatorAddr() github_com_cosmos_cosmos_sdk_types.AccAddress { + if m != nil { + return m.DelegatorAddr + } + return nil +} + +func (m *QueryDelegationRequest) GetValidatorAddr() github_com_cosmos_cosmos_sdk_types.ValAddress { + if m != nil { + return m.ValidatorAddr + } + return nil +} + +// QueryDelegationResponse is response type for the Query/Delegation RPC method +type QueryDelegationResponse struct { + DelegationResponse *DelegationResponse `protobuf:"bytes,1,opt,name=delegation_response,json=delegationResponse,proto3,casttype=DelegationResponse" json:"delegation_response,omitempty"` +} + +func (m *QueryDelegationResponse) Reset() { *m = QueryDelegationResponse{} } +func (m *QueryDelegationResponse) String() string { return proto.CompactTextString(m) } +func (*QueryDelegationResponse) ProtoMessage() {} +func (*QueryDelegationResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_802d43a0c79dce0e, []int{9} +} +func (m *QueryDelegationResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryDelegationResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryDelegationResponse.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 *QueryDelegationResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryDelegationResponse.Merge(m, src) +} +func (m *QueryDelegationResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryDelegationResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryDelegationResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryDelegationResponse proto.InternalMessageInfo + +func (m *QueryDelegationResponse) GetDelegationResponse() *DelegationResponse { + if m != nil { + return m.DelegationResponse + } + return nil +} + +// QueryUnbondingDelegationRequest is request type for the Query/UnbondingDelegation RPC method +type QueryUnbondingDelegationRequest struct { + DelegatorAddr github_com_cosmos_cosmos_sdk_types.AccAddress `protobuf:"bytes,1,opt,name=delegator_addr,json=delegatorAddr,proto3,casttype=github.com/cosmos/cosmos-sdk/types.AccAddress" json:"delegator_addr,omitempty"` + ValidatorAddr github_com_cosmos_cosmos_sdk_types.ValAddress `protobuf:"bytes,2,opt,name=validator_addr,json=validatorAddr,proto3,casttype=github.com/cosmos/cosmos-sdk/types.ValAddress" json:"validator_addr,omitempty"` +} + +func (m *QueryUnbondingDelegationRequest) Reset() { *m = QueryUnbondingDelegationRequest{} } +func (m *QueryUnbondingDelegationRequest) String() string { return proto.CompactTextString(m) } +func (*QueryUnbondingDelegationRequest) ProtoMessage() {} +func (*QueryUnbondingDelegationRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_802d43a0c79dce0e, []int{10} +} +func (m *QueryUnbondingDelegationRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryUnbondingDelegationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryUnbondingDelegationRequest.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 *QueryUnbondingDelegationRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryUnbondingDelegationRequest.Merge(m, src) +} +func (m *QueryUnbondingDelegationRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryUnbondingDelegationRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryUnbondingDelegationRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryUnbondingDelegationRequest proto.InternalMessageInfo + +func (m *QueryUnbondingDelegationRequest) GetDelegatorAddr() github_com_cosmos_cosmos_sdk_types.AccAddress { + if m != nil { + return m.DelegatorAddr + } + return nil +} + +func (m *QueryUnbondingDelegationRequest) GetValidatorAddr() github_com_cosmos_cosmos_sdk_types.ValAddress { + if m != nil { + return m.ValidatorAddr + } + return nil +} + +// QueryDelegationResponse is response type for the Query/UnbondingDelegation RPC method +type QueryUnbondingDelegationResponse struct { + Unbond UnbondingDelegation `protobuf:"bytes,1,opt,name=unbond,proto3" json:"unbond"` +} + +func (m *QueryUnbondingDelegationResponse) Reset() { *m = QueryUnbondingDelegationResponse{} } +func (m *QueryUnbondingDelegationResponse) String() string { return proto.CompactTextString(m) } +func (*QueryUnbondingDelegationResponse) ProtoMessage() {} +func (*QueryUnbondingDelegationResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_802d43a0c79dce0e, []int{11} +} +func (m *QueryUnbondingDelegationResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryUnbondingDelegationResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryUnbondingDelegationResponse.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 *QueryUnbondingDelegationResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryUnbondingDelegationResponse.Merge(m, src) +} +func (m *QueryUnbondingDelegationResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryUnbondingDelegationResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryUnbondingDelegationResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryUnbondingDelegationResponse proto.InternalMessageInfo + +func (m *QueryUnbondingDelegationResponse) GetUnbond() UnbondingDelegation { + if m != nil { + return m.Unbond + } + return UnbondingDelegation{} +} + +// QueryDelegatorDelegationsRequest is request type for the Query/DelegatorDelegations RPC method +type QueryDelegatorDelegationsRequest struct { + DelegatorAddr github_com_cosmos_cosmos_sdk_types.AccAddress `protobuf:"bytes,1,opt,name=delegator_addr,json=delegatorAddr,proto3,casttype=github.com/cosmos/cosmos-sdk/types.AccAddress" json:"delegator_addr,omitempty"` + Req *query.PageRequest `protobuf:"bytes,2,opt,name=req,proto3" json:"req,omitempty"` +} + +func (m *QueryDelegatorDelegationsRequest) Reset() { *m = QueryDelegatorDelegationsRequest{} } +func (m *QueryDelegatorDelegationsRequest) String() string { return proto.CompactTextString(m) } +func (*QueryDelegatorDelegationsRequest) ProtoMessage() {} +func (*QueryDelegatorDelegationsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_802d43a0c79dce0e, []int{12} +} +func (m *QueryDelegatorDelegationsRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryDelegatorDelegationsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryDelegatorDelegationsRequest.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 *QueryDelegatorDelegationsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryDelegatorDelegationsRequest.Merge(m, src) +} +func (m *QueryDelegatorDelegationsRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryDelegatorDelegationsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryDelegatorDelegationsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryDelegatorDelegationsRequest proto.InternalMessageInfo + +func (m *QueryDelegatorDelegationsRequest) GetDelegatorAddr() github_com_cosmos_cosmos_sdk_types.AccAddress { + if m != nil { + return m.DelegatorAddr + } + return nil +} + +func (m *QueryDelegatorDelegationsRequest) GetReq() *query.PageRequest { + if m != nil { + return m.Req + } + return nil +} + +// QueryDelegatorDelegationsResponse is response type for the Query/DelegatorDelegations RPC method +type QueryDelegatorDelegationsResponse struct { + DelegationResponses []DelegationResponse `protobuf:"bytes,1,rep,name=delegation_responses,json=delegationResponses,proto3" json:"delegation_responses"` + Res *query.PageResponse `protobuf:"bytes,2,opt,name=res,proto3" json:"res,omitempty"` +} + +func (m *QueryDelegatorDelegationsResponse) Reset() { *m = QueryDelegatorDelegationsResponse{} } +func (m *QueryDelegatorDelegationsResponse) String() string { return proto.CompactTextString(m) } +func (*QueryDelegatorDelegationsResponse) ProtoMessage() {} +func (*QueryDelegatorDelegationsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_802d43a0c79dce0e, []int{13} +} +func (m *QueryDelegatorDelegationsResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryDelegatorDelegationsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryDelegatorDelegationsResponse.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 *QueryDelegatorDelegationsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryDelegatorDelegationsResponse.Merge(m, src) +} +func (m *QueryDelegatorDelegationsResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryDelegatorDelegationsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryDelegatorDelegationsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryDelegatorDelegationsResponse proto.InternalMessageInfo + +func (m *QueryDelegatorDelegationsResponse) GetDelegationResponses() []DelegationResponse { + if m != nil { + return m.DelegationResponses + } + return nil +} + +func (m *QueryDelegatorDelegationsResponse) GetRes() *query.PageResponse { + if m != nil { + return m.Res + } + return nil +} + +// QueryDelegatorUnbondingDelegationsRequest is request type for the Query/DelegatorUnbondingDelegations RPC method +type QueryDelegatorUnbondingDelegationsRequest struct { + DelegatorAddr github_com_cosmos_cosmos_sdk_types.AccAddress `protobuf:"bytes,1,opt,name=delegator_addr,json=delegatorAddr,proto3,casttype=github.com/cosmos/cosmos-sdk/types.AccAddress" json:"delegator_addr,omitempty"` + Req *query.PageRequest `protobuf:"bytes,2,opt,name=req,proto3" json:"req,omitempty"` +} + +func (m *QueryDelegatorUnbondingDelegationsRequest) Reset() { + *m = QueryDelegatorUnbondingDelegationsRequest{} +} +func (m *QueryDelegatorUnbondingDelegationsRequest) String() string { + return proto.CompactTextString(m) +} +func (*QueryDelegatorUnbondingDelegationsRequest) ProtoMessage() {} +func (*QueryDelegatorUnbondingDelegationsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_802d43a0c79dce0e, []int{14} +} +func (m *QueryDelegatorUnbondingDelegationsRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryDelegatorUnbondingDelegationsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryDelegatorUnbondingDelegationsRequest.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 *QueryDelegatorUnbondingDelegationsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryDelegatorUnbondingDelegationsRequest.Merge(m, src) +} +func (m *QueryDelegatorUnbondingDelegationsRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryDelegatorUnbondingDelegationsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryDelegatorUnbondingDelegationsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryDelegatorUnbondingDelegationsRequest proto.InternalMessageInfo + +func (m *QueryDelegatorUnbondingDelegationsRequest) GetDelegatorAddr() github_com_cosmos_cosmos_sdk_types.AccAddress { + if m != nil { + return m.DelegatorAddr + } + return nil +} + +func (m *QueryDelegatorUnbondingDelegationsRequest) GetReq() *query.PageRequest { + if m != nil { + return m.Req + } + return nil +} + +// QueryUnbondingDelegatorDelegationsResponse is response type for the Query/UnbondingDelegatorDelegations RPC method +type QueryDelegatorUnbondingDelegationsResponse struct { + UnbondingResponses []UnbondingDelegation `protobuf:"bytes,1,rep,name=unbonding_responses,json=unbondingResponses,proto3" json:"unbonding_responses"` + Res *query.PageResponse `protobuf:"bytes,2,opt,name=res,proto3" json:"res,omitempty"` +} + +func (m *QueryDelegatorUnbondingDelegationsResponse) Reset() { + *m = QueryDelegatorUnbondingDelegationsResponse{} +} +func (m *QueryDelegatorUnbondingDelegationsResponse) String() string { + return proto.CompactTextString(m) +} +func (*QueryDelegatorUnbondingDelegationsResponse) ProtoMessage() {} +func (*QueryDelegatorUnbondingDelegationsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_802d43a0c79dce0e, []int{15} +} +func (m *QueryDelegatorUnbondingDelegationsResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryDelegatorUnbondingDelegationsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryDelegatorUnbondingDelegationsResponse.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 *QueryDelegatorUnbondingDelegationsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryDelegatorUnbondingDelegationsResponse.Merge(m, src) +} +func (m *QueryDelegatorUnbondingDelegationsResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryDelegatorUnbondingDelegationsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryDelegatorUnbondingDelegationsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryDelegatorUnbondingDelegationsResponse proto.InternalMessageInfo + +func (m *QueryDelegatorUnbondingDelegationsResponse) GetUnbondingResponses() []UnbondingDelegation { + if m != nil { + return m.UnbondingResponses + } + return nil +} + +func (m *QueryDelegatorUnbondingDelegationsResponse) GetRes() *query.PageResponse { + if m != nil { + return m.Res + } + return nil +} + +// QueryRedelegationsRequest is request type for the Query/Redelegations RPC method +type QueryRedelegationsRequest struct { + DelegatorAddr github_com_cosmos_cosmos_sdk_types.AccAddress `protobuf:"bytes,1,opt,name=delegator_addr,json=delegatorAddr,proto3,casttype=github.com/cosmos/cosmos-sdk/types.AccAddress" json:"delegator_addr,omitempty"` + SrcValidatorAddr github_com_cosmos_cosmos_sdk_types.ValAddress `protobuf:"bytes,2,opt,name=src_validator_addr,json=srcValidatorAddr,proto3,casttype=github.com/cosmos/cosmos-sdk/types.ValAddress" json:"src_validator_addr,omitempty"` + DstValidatorAddr github_com_cosmos_cosmos_sdk_types.ValAddress `protobuf:"bytes,3,opt,name=dst_validator_addr,json=dstValidatorAddr,proto3,casttype=github.com/cosmos/cosmos-sdk/types.ValAddress" json:"dst_validator_addr,omitempty"` + Req *query.PageRequest `protobuf:"bytes,4,opt,name=req,proto3" json:"req,omitempty"` +} + +func (m *QueryRedelegationsRequest) Reset() { *m = QueryRedelegationsRequest{} } +func (m *QueryRedelegationsRequest) String() string { return proto.CompactTextString(m) } +func (*QueryRedelegationsRequest) ProtoMessage() {} +func (*QueryRedelegationsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_802d43a0c79dce0e, []int{16} +} +func (m *QueryRedelegationsRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryRedelegationsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryRedelegationsRequest.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 *QueryRedelegationsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryRedelegationsRequest.Merge(m, src) +} +func (m *QueryRedelegationsRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryRedelegationsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryRedelegationsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryRedelegationsRequest proto.InternalMessageInfo + +func (m *QueryRedelegationsRequest) GetDelegatorAddr() github_com_cosmos_cosmos_sdk_types.AccAddress { + if m != nil { + return m.DelegatorAddr + } + return nil +} + +func (m *QueryRedelegationsRequest) GetSrcValidatorAddr() github_com_cosmos_cosmos_sdk_types.ValAddress { + if m != nil { + return m.SrcValidatorAddr + } + return nil +} + +func (m *QueryRedelegationsRequest) GetDstValidatorAddr() github_com_cosmos_cosmos_sdk_types.ValAddress { + if m != nil { + return m.DstValidatorAddr + } + return nil +} + +func (m *QueryRedelegationsRequest) GetReq() *query.PageRequest { + if m != nil { + return m.Req + } + return nil +} + +// QueryRedelegationsResponse is response type for the Query/Redelegations RPC method +type QueryRedelegationsResponse struct { + RedelegationResponses []RedelegationResponse `protobuf:"bytes,1,rep,name=redelegation_responses,json=redelegationResponses,proto3" json:"redelegation_responses"` + Res *query.PageResponse `protobuf:"bytes,2,opt,name=res,proto3" json:"res,omitempty"` +} + +func (m *QueryRedelegationsResponse) Reset() { *m = QueryRedelegationsResponse{} } +func (m *QueryRedelegationsResponse) String() string { return proto.CompactTextString(m) } +func (*QueryRedelegationsResponse) ProtoMessage() {} +func (*QueryRedelegationsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_802d43a0c79dce0e, []int{17} +} +func (m *QueryRedelegationsResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryRedelegationsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryRedelegationsResponse.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 *QueryRedelegationsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryRedelegationsResponse.Merge(m, src) +} +func (m *QueryRedelegationsResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryRedelegationsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryRedelegationsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryRedelegationsResponse proto.InternalMessageInfo + +func (m *QueryRedelegationsResponse) GetRedelegationResponses() []RedelegationResponse { + if m != nil { + return m.RedelegationResponses + } + return nil +} + +func (m *QueryRedelegationsResponse) GetRes() *query.PageResponse { + if m != nil { + return m.Res + } + return nil +} + +// QueryDelegatorValidatorsRequest is request type for the Query/DelegatorValidators RPC method +type QueryDelegatorValidatorsRequest struct { + DelegatorAddr github_com_cosmos_cosmos_sdk_types.AccAddress `protobuf:"bytes,1,opt,name=delegator_addr,json=delegatorAddr,proto3,casttype=github.com/cosmos/cosmos-sdk/types.AccAddress" json:"delegator_addr,omitempty"` + Req *query.PageRequest `protobuf:"bytes,2,opt,name=req,proto3" json:"req,omitempty"` +} + +func (m *QueryDelegatorValidatorsRequest) Reset() { *m = QueryDelegatorValidatorsRequest{} } +func (m *QueryDelegatorValidatorsRequest) String() string { return proto.CompactTextString(m) } +func (*QueryDelegatorValidatorsRequest) ProtoMessage() {} +func (*QueryDelegatorValidatorsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_802d43a0c79dce0e, []int{18} +} +func (m *QueryDelegatorValidatorsRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryDelegatorValidatorsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryDelegatorValidatorsRequest.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 *QueryDelegatorValidatorsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryDelegatorValidatorsRequest.Merge(m, src) +} +func (m *QueryDelegatorValidatorsRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryDelegatorValidatorsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryDelegatorValidatorsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryDelegatorValidatorsRequest proto.InternalMessageInfo + +func (m *QueryDelegatorValidatorsRequest) GetDelegatorAddr() github_com_cosmos_cosmos_sdk_types.AccAddress { + if m != nil { + return m.DelegatorAddr + } + return nil +} + +func (m *QueryDelegatorValidatorsRequest) GetReq() *query.PageRequest { + if m != nil { + return m.Req + } + return nil +} + +// QueryDelegatorValidatorsResponse is response type for the Query/DelegatorValidators RPC method +type QueryDelegatorValidatorsResponse struct { + Validators []Validator `protobuf:"bytes,1,rep,name=validators,proto3" json:"validators"` + Res *query.PageResponse `protobuf:"bytes,2,opt,name=res,proto3" json:"res,omitempty"` +} + +func (m *QueryDelegatorValidatorsResponse) Reset() { *m = QueryDelegatorValidatorsResponse{} } +func (m *QueryDelegatorValidatorsResponse) String() string { return proto.CompactTextString(m) } +func (*QueryDelegatorValidatorsResponse) ProtoMessage() {} +func (*QueryDelegatorValidatorsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_802d43a0c79dce0e, []int{19} +} +func (m *QueryDelegatorValidatorsResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryDelegatorValidatorsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryDelegatorValidatorsResponse.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 *QueryDelegatorValidatorsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryDelegatorValidatorsResponse.Merge(m, src) +} +func (m *QueryDelegatorValidatorsResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryDelegatorValidatorsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryDelegatorValidatorsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryDelegatorValidatorsResponse proto.InternalMessageInfo + +func (m *QueryDelegatorValidatorsResponse) GetValidators() []Validator { + if m != nil { + return m.Validators + } + return nil +} + +func (m *QueryDelegatorValidatorsResponse) GetRes() *query.PageResponse { + if m != nil { + return m.Res + } + return nil +} + +// QueryDelegatorValidatorRequest is request type for the Query/DelegatorValidator RPC method +type QueryDelegatorValidatorRequest struct { + DelegatorAddr github_com_cosmos_cosmos_sdk_types.AccAddress `protobuf:"bytes,1,opt,name=delegator_addr,json=delegatorAddr,proto3,casttype=github.com/cosmos/cosmos-sdk/types.AccAddress" json:"delegator_addr,omitempty"` + ValidatorAddr github_com_cosmos_cosmos_sdk_types.ValAddress `protobuf:"bytes,2,opt,name=validator_addr,json=validatorAddr,proto3,casttype=github.com/cosmos/cosmos-sdk/types.ValAddress" json:"validator_addr,omitempty"` +} + +func (m *QueryDelegatorValidatorRequest) Reset() { *m = QueryDelegatorValidatorRequest{} } +func (m *QueryDelegatorValidatorRequest) String() string { return proto.CompactTextString(m) } +func (*QueryDelegatorValidatorRequest) ProtoMessage() {} +func (*QueryDelegatorValidatorRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_802d43a0c79dce0e, []int{20} +} +func (m *QueryDelegatorValidatorRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryDelegatorValidatorRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryDelegatorValidatorRequest.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 *QueryDelegatorValidatorRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryDelegatorValidatorRequest.Merge(m, src) +} +func (m *QueryDelegatorValidatorRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryDelegatorValidatorRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryDelegatorValidatorRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryDelegatorValidatorRequest proto.InternalMessageInfo + +func (m *QueryDelegatorValidatorRequest) GetDelegatorAddr() github_com_cosmos_cosmos_sdk_types.AccAddress { + if m != nil { + return m.DelegatorAddr + } + return nil +} + +func (m *QueryDelegatorValidatorRequest) GetValidatorAddr() github_com_cosmos_cosmos_sdk_types.ValAddress { + if m != nil { + return m.ValidatorAddr + } + return nil +} + +// QueryDelegatorValidatorResponse response type for the Query/DelegatorValidator RPC method +type QueryDelegatorValidatorResponse struct { + Validator Validator `protobuf:"bytes,1,opt,name=validator,proto3" json:"validator"` +} + +func (m *QueryDelegatorValidatorResponse) Reset() { *m = QueryDelegatorValidatorResponse{} } +func (m *QueryDelegatorValidatorResponse) String() string { return proto.CompactTextString(m) } +func (*QueryDelegatorValidatorResponse) ProtoMessage() {} +func (*QueryDelegatorValidatorResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_802d43a0c79dce0e, []int{21} +} +func (m *QueryDelegatorValidatorResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryDelegatorValidatorResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryDelegatorValidatorResponse.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 *QueryDelegatorValidatorResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryDelegatorValidatorResponse.Merge(m, src) +} +func (m *QueryDelegatorValidatorResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryDelegatorValidatorResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryDelegatorValidatorResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryDelegatorValidatorResponse proto.InternalMessageInfo + +func (m *QueryDelegatorValidatorResponse) GetValidator() Validator { + if m != nil { + return m.Validator + } + return Validator{} +} + +// QueryHistoricalInfoRequest is request type for the Query/HistoricalInfo RPC method +type QueryHistoricalInfoRequest struct { + Height int64 `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"` +} + +func (m *QueryHistoricalInfoRequest) Reset() { *m = QueryHistoricalInfoRequest{} } +func (m *QueryHistoricalInfoRequest) String() string { return proto.CompactTextString(m) } +func (*QueryHistoricalInfoRequest) ProtoMessage() {} +func (*QueryHistoricalInfoRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_802d43a0c79dce0e, []int{22} +} +func (m *QueryHistoricalInfoRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryHistoricalInfoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryHistoricalInfoRequest.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 *QueryHistoricalInfoRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryHistoricalInfoRequest.Merge(m, src) +} +func (m *QueryHistoricalInfoRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryHistoricalInfoRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryHistoricalInfoRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryHistoricalInfoRequest proto.InternalMessageInfo + +func (m *QueryHistoricalInfoRequest) GetHeight() int64 { + if m != nil { + return m.Height + } + return 0 +} + +// QueryHistoricalInfoResponse is response type for the Query/HistoricalInfo RPC method +type QueryHistoricalInfoResponse struct { + Hist *HistoricalInfo `protobuf:"bytes,1,opt,name=hist,proto3" json:"hist,omitempty"` +} + +func (m *QueryHistoricalInfoResponse) Reset() { *m = QueryHistoricalInfoResponse{} } +func (m *QueryHistoricalInfoResponse) String() string { return proto.CompactTextString(m) } +func (*QueryHistoricalInfoResponse) ProtoMessage() {} +func (*QueryHistoricalInfoResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_802d43a0c79dce0e, []int{23} +} +func (m *QueryHistoricalInfoResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryHistoricalInfoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryHistoricalInfoResponse.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 *QueryHistoricalInfoResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryHistoricalInfoResponse.Merge(m, src) +} +func (m *QueryHistoricalInfoResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryHistoricalInfoResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryHistoricalInfoResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryHistoricalInfoResponse proto.InternalMessageInfo + +func (m *QueryHistoricalInfoResponse) GetHist() *HistoricalInfo { + if m != nil { + return m.Hist + } + return nil +} + +// QueryPoolRequest is request type for the Query/Pool RPC method +type QueryPoolRequest struct { +} + +func (m *QueryPoolRequest) Reset() { *m = QueryPoolRequest{} } +func (m *QueryPoolRequest) String() string { return proto.CompactTextString(m) } +func (*QueryPoolRequest) ProtoMessage() {} +func (*QueryPoolRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_802d43a0c79dce0e, []int{24} +} +func (m *QueryPoolRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryPoolRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryPoolRequest.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 *QueryPoolRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryPoolRequest.Merge(m, src) +} +func (m *QueryPoolRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryPoolRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryPoolRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryPoolRequest proto.InternalMessageInfo + +// QueryPoolResponse is response type for the Query/Pool RPC method +type QueryPoolResponse struct { + Pool Pool `protobuf:"bytes,1,opt,name=pool,proto3" json:"pool"` +} + +func (m *QueryPoolResponse) Reset() { *m = QueryPoolResponse{} } +func (m *QueryPoolResponse) String() string { return proto.CompactTextString(m) } +func (*QueryPoolResponse) ProtoMessage() {} +func (*QueryPoolResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_802d43a0c79dce0e, []int{25} +} +func (m *QueryPoolResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryPoolResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryPoolResponse.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 *QueryPoolResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryPoolResponse.Merge(m, src) +} +func (m *QueryPoolResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryPoolResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryPoolResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryPoolResponse proto.InternalMessageInfo + +func (m *QueryPoolResponse) GetPool() Pool { + if m != nil { + return m.Pool + } + return Pool{} +} + +// QueryParametersRequest is request type for the Query/Parameters RPC method +type QueryParamsRequest struct { +} + +func (m *QueryParamsRequest) Reset() { *m = QueryParamsRequest{} } +func (m *QueryParamsRequest) String() string { return proto.CompactTextString(m) } +func (*QueryParamsRequest) ProtoMessage() {} +func (*QueryParamsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_802d43a0c79dce0e, []int{26} +} +func (m *QueryParamsRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryParamsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryParamsRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *QueryParamsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryParamsRequest.Merge(m, src) +} +func (m *QueryParamsRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryParamsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryParamsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryParamsRequest proto.InternalMessageInfo + +// QueryParametersResponse is response type for the Query/Parameters RPC method +type QueryParamsResponse struct { + Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"` + Res *query.PageResponse `protobuf:"bytes,2,opt,name=res,proto3" json:"res,omitempty"` +} + +func (m *QueryParamsResponse) Reset() { *m = QueryParamsResponse{} } +func (m *QueryParamsResponse) String() string { return proto.CompactTextString(m) } +func (*QueryParamsResponse) ProtoMessage() {} +func (*QueryParamsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_802d43a0c79dce0e, []int{27} +} +func (m *QueryParamsResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryParamsResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *QueryParamsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryParamsResponse.Merge(m, src) +} +func (m *QueryParamsResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryParamsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryParamsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryParamsResponse proto.InternalMessageInfo + +func (m *QueryParamsResponse) GetParams() Params { + if m != nil { + return m.Params + } + return Params{} +} + +func (m *QueryParamsResponse) GetRes() *query.PageResponse { + if m != nil { + return m.Res + } + return nil +} + +func init() { + proto.RegisterType((*QueryValidatorsRequest)(nil), "cosmos.staking.QueryValidatorsRequest") + proto.RegisterType((*QueryValidatorsResponse)(nil), "cosmos.staking.QueryValidatorsResponse") + proto.RegisterType((*QueryValidatorRequest)(nil), "cosmos.staking.QueryValidatorRequest") + proto.RegisterType((*QueryValidatorResponse)(nil), "cosmos.staking.QueryValidatorResponse") + proto.RegisterType((*QueryValidatorDelegationsRequest)(nil), "cosmos.staking.QueryValidatorDelegationsRequest") + proto.RegisterType((*QueryValidatorDelegationsResponse)(nil), "cosmos.staking.QueryValidatorDelegationsResponse") + proto.RegisterType((*QueryValidatorUnbondingDelegationsRequest)(nil), "cosmos.staking.QueryValidatorUnbondingDelegationsRequest") + proto.RegisterType((*QueryValidatorUnbondingDelegationsResponse)(nil), "cosmos.staking.QueryValidatorUnbondingDelegationsResponse") + proto.RegisterType((*QueryDelegationRequest)(nil), "cosmos.staking.QueryDelegationRequest") + proto.RegisterType((*QueryDelegationResponse)(nil), "cosmos.staking.QueryDelegationResponse") + proto.RegisterType((*QueryUnbondingDelegationRequest)(nil), "cosmos.staking.QueryUnbondingDelegationRequest") + proto.RegisterType((*QueryUnbondingDelegationResponse)(nil), "cosmos.staking.QueryUnbondingDelegationResponse") + proto.RegisterType((*QueryDelegatorDelegationsRequest)(nil), "cosmos.staking.QueryDelegatorDelegationsRequest") + proto.RegisterType((*QueryDelegatorDelegationsResponse)(nil), "cosmos.staking.QueryDelegatorDelegationsResponse") + proto.RegisterType((*QueryDelegatorUnbondingDelegationsRequest)(nil), "cosmos.staking.QueryDelegatorUnbondingDelegationsRequest") + proto.RegisterType((*QueryDelegatorUnbondingDelegationsResponse)(nil), "cosmos.staking.QueryDelegatorUnbondingDelegationsResponse") + proto.RegisterType((*QueryRedelegationsRequest)(nil), "cosmos.staking.QueryRedelegationsRequest") + proto.RegisterType((*QueryRedelegationsResponse)(nil), "cosmos.staking.QueryRedelegationsResponse") + proto.RegisterType((*QueryDelegatorValidatorsRequest)(nil), "cosmos.staking.QueryDelegatorValidatorsRequest") + proto.RegisterType((*QueryDelegatorValidatorsResponse)(nil), "cosmos.staking.QueryDelegatorValidatorsResponse") + proto.RegisterType((*QueryDelegatorValidatorRequest)(nil), "cosmos.staking.QueryDelegatorValidatorRequest") + proto.RegisterType((*QueryDelegatorValidatorResponse)(nil), "cosmos.staking.QueryDelegatorValidatorResponse") + proto.RegisterType((*QueryHistoricalInfoRequest)(nil), "cosmos.staking.QueryHistoricalInfoRequest") + proto.RegisterType((*QueryHistoricalInfoResponse)(nil), "cosmos.staking.QueryHistoricalInfoResponse") + proto.RegisterType((*QueryPoolRequest)(nil), "cosmos.staking.QueryPoolRequest") + proto.RegisterType((*QueryPoolResponse)(nil), "cosmos.staking.QueryPoolResponse") + proto.RegisterType((*QueryParamsRequest)(nil), "cosmos.staking.QueryParamsRequest") + proto.RegisterType((*QueryParamsResponse)(nil), "cosmos.staking.QueryParamsResponse") +} + +func init() { proto.RegisterFile("cosmos/staking/query.proto", fileDescriptor_802d43a0c79dce0e) } + +var fileDescriptor_802d43a0c79dce0e = []byte{ + // 1099 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x58, 0x4f, 0x6f, 0x1b, 0x45, + 0x14, 0xf7, 0x24, 0xc6, 0x52, 0x1e, 0x6d, 0x54, 0xc6, 0xae, 0x49, 0xb7, 0xd4, 0x76, 0xb7, 0x50, + 0xfa, 0xd7, 0x4e, 0x43, 0x2f, 0x20, 0x21, 0x94, 0x50, 0x21, 0x38, 0x20, 0xb5, 0x8b, 0x08, 0xa8, + 0x80, 0xcc, 0xc6, 0xbb, 0xac, 0x57, 0x71, 0x3c, 0xce, 0xce, 0x1a, 0x08, 0x12, 0x57, 0xc4, 0x11, + 0x6e, 0x7c, 0x04, 0x40, 0x82, 0x03, 0x07, 0xbe, 0x01, 0xa2, 0x07, 0x0e, 0x3d, 0x80, 0xc4, 0x29, + 0xa0, 0x84, 0x4f, 0xd1, 0x13, 0xda, 0xd9, 0xb7, 0xe3, 0xf5, 0xee, 0xec, 0x66, 0x9d, 0xa6, 0x90, + 0x9e, 0x6c, 0xcf, 0xbc, 0xf7, 0x7b, 0xbf, 0x79, 0xef, 0xcd, 0x7b, 0x6f, 0x0c, 0x5a, 0x8f, 0xf1, + 0x2d, 0xc6, 0x3b, 0xdc, 0x37, 0x37, 0xdd, 0xa1, 0xd3, 0xd9, 0x1e, 0xdb, 0xde, 0x4e, 0x7b, 0xe4, + 0x31, 0x9f, 0xd1, 0xc5, 0x70, 0xaf, 0x8d, 0x7b, 0xda, 0x39, 0x94, 0x15, 0x32, 0x9d, 0x91, 0xe9, + 0xb8, 0x43, 0xd3, 0x77, 0xd9, 0x30, 0x14, 0xd7, 0x6a, 0x0e, 0x73, 0x98, 0xf8, 0xda, 0x09, 0xbe, + 0xe1, 0xea, 0x33, 0x09, 0x03, 0xf8, 0x19, 0xee, 0xea, 0x1f, 0x40, 0xfd, 0x4e, 0x80, 0xb6, 0x6e, + 0x0e, 0x5c, 0xcb, 0xf4, 0x99, 0xc7, 0x0d, 0x7b, 0x7b, 0x6c, 0x73, 0x9f, 0xd6, 0xa1, 0xc2, 0x7d, + 0xd3, 0x1f, 0xf3, 0x25, 0xd2, 0x22, 0x97, 0x16, 0x0c, 0xfc, 0x45, 0xaf, 0xc2, 0xbc, 0x67, 0x6f, + 0x2f, 0xcd, 0xb5, 0xc8, 0xa5, 0x27, 0x57, 0xce, 0xb4, 0x91, 0x62, 0x48, 0xfb, 0xb6, 0xe9, 0xd8, + 0xa8, 0x6f, 0x04, 0x52, 0xfa, 0x97, 0x04, 0x9e, 0x4e, 0xe1, 0xf3, 0x11, 0x1b, 0x72, 0x9b, 0xbe, + 0x02, 0xf0, 0xb1, 0x5c, 0x5d, 0x22, 0xad, 0xf9, 0x38, 0x5e, 0xc4, 0x52, 0xea, 0xad, 0x95, 0xef, + 0xed, 0x36, 0x4b, 0x46, 0x4c, 0x85, 0x5e, 0x0b, 0x98, 0x70, 0x64, 0xa2, 0xa9, 0x98, 0x84, 0x96, + 0x02, 0x2a, 0x5c, 0xdf, 0x86, 0xd3, 0xd3, 0x4c, 0xa2, 0x83, 0xbe, 0x0b, 0x8b, 0x12, 0xb4, 0x6b, + 0x5a, 0x96, 0x27, 0x0e, 0x7c, 0x62, 0xed, 0xc6, 0x83, 0xdd, 0xe6, 0x75, 0xc7, 0xf5, 0xfb, 0xe3, + 0x8d, 0x76, 0x8f, 0x6d, 0x75, 0xd0, 0x8f, 0xe1, 0xc7, 0x75, 0x6e, 0x6d, 0x76, 0xfc, 0x9d, 0x91, + 0xcd, 0x03, 0x8a, 0xab, 0x96, 0xe5, 0xd9, 0x9c, 0x1b, 0x27, 0x25, 0x50, 0xb0, 0xa2, 0xbf, 0x93, + 0x74, 0xae, 0x3c, 0xfb, 0xcb, 0xb0, 0x20, 0x45, 0x85, 0xb9, 0x02, 0x47, 0x9f, 0x68, 0xe8, 0xdf, + 0x11, 0x68, 0x4d, 0x23, 0xdf, 0xb2, 0x07, 0xb6, 0x23, 0x92, 0x81, 0x3f, 0xf2, 0x73, 0xcd, 0x96, + 0x02, 0xbf, 0x10, 0x38, 0x9f, 0xc3, 0x15, 0x1d, 0xe2, 0x41, 0xcd, 0x92, 0xcb, 0x5d, 0x0f, 0x97, + 0xa3, 0xb4, 0xd0, 0x93, 0xbe, 0x99, 0x40, 0x44, 0x08, 0x6b, 0x67, 0x03, 0x27, 0x7d, 0xff, 0x57, + 0xb3, 0x9a, 0xde, 0xe3, 0x46, 0xd5, 0x4a, 0x2f, 0xce, 0x98, 0x3f, 0x3f, 0x11, 0xb8, 0x3c, 0x7d, + 0x8e, 0xb7, 0x87, 0x1b, 0x6c, 0x68, 0xb9, 0x43, 0xe7, 0xf8, 0x3a, 0xff, 0x67, 0x02, 0x57, 0x8a, + 0x90, 0xc6, 0x28, 0xdc, 0x85, 0xea, 0x38, 0xda, 0x4f, 0x05, 0xe1, 0x42, 0x32, 0x08, 0x0a, 0x28, + 0x4c, 0x55, 0x2a, 0x51, 0x0e, 0xeb, 0xed, 0xdf, 0x08, 0xde, 0x9d, 0x78, 0x34, 0xa5, 0x6b, 0x31, + 0x9a, 0x87, 0x73, 0xed, 0x6a, 0xaf, 0x27, 0x5d, 0x2b, 0x81, 0x84, 0x6b, 0xd3, 0x41, 0x9b, 0x3b, + 0xa2, 0x4a, 0xf0, 0x45, 0x54, 0x07, 0xd3, 0xc9, 0x49, 0x37, 0xa1, 0xaa, 0x48, 0x7d, 0xac, 0x0a, + 0x45, 0x32, 0xbf, 0xfe, 0x60, 0xb7, 0x49, 0xd3, 0xeb, 0x06, 0x4d, 0x27, 0xbd, 0xfe, 0x07, 0x81, + 0xa6, 0x20, 0xa2, 0x08, 0xde, 0xe3, 0xec, 0x60, 0x1b, 0x0b, 0xa2, 0xf2, 0x58, 0xe8, 0xe8, 0x55, + 0xa8, 0x84, 0x79, 0x89, 0xbe, 0x9d, 0x21, 0xa1, 0x51, 0x71, 0x52, 0x78, 0x6f, 0x45, 0xe7, 0x52, + 0xdf, 0xfd, 0x47, 0xe4, 0xbf, 0x99, 0xee, 0xfe, 0x8f, 0x51, 0xe1, 0x55, 0x73, 0x45, 0xa7, 0xbc, + 0xf7, 0xd0, 0x85, 0x37, 0xf4, 0xd0, 0x51, 0x56, 0x58, 0x49, 0xf8, 0x80, 0x0a, 0x7b, 0x1c, 0xbc, + 0x2c, 0x2b, 0xec, 0x01, 0xa4, 0x8f, 0x5d, 0x85, 0xfd, 0x67, 0x0e, 0xce, 0x08, 0xe2, 0x86, 0x6d, + 0xfd, 0x97, 0xde, 0xed, 0x02, 0xe5, 0x5e, 0xaf, 0x7b, 0x54, 0x75, 0xe0, 0x14, 0xf7, 0x7a, 0xeb, + 0x53, 0x0d, 0xb2, 0x0b, 0xd4, 0xe2, 0x7e, 0xd2, 0xc0, 0xfc, 0xa1, 0x0d, 0x58, 0xdc, 0x5f, 0x57, + 0x75, 0xe0, 0x72, 0xa1, 0xfc, 0xf8, 0x81, 0x80, 0xa6, 0x72, 0x33, 0xe6, 0x83, 0x09, 0x75, 0xcf, + 0xce, 0xb9, 0x80, 0xcf, 0x26, 0x53, 0x22, 0x0e, 0x93, 0xb8, 0x82, 0xa7, 0x3d, 0xfb, 0xe1, 0x2f, + 0xe1, 0xb7, 0x51, 0x83, 0x90, 0xf9, 0x9c, 0x7e, 0x1a, 0x1c, 0x93, 0xab, 0xf7, 0x75, 0xaa, 0x18, + 0xff, 0xff, 0xaf, 0x8c, 0xdf, 0x09, 0x34, 0x32, 0x38, 0x3d, 0xce, 0xed, 0xf5, 0xc3, 0xcc, 0xa4, + 0x38, 0xaa, 0x27, 0xcd, 0x4d, 0xbc, 0x26, 0xaf, 0xbb, 0xdc, 0x67, 0x9e, 0xdb, 0x33, 0x07, 0x6f, + 0x0c, 0x3f, 0x62, 0xb1, 0xc7, 0x68, 0xdf, 0x76, 0x9d, 0xbe, 0x2f, 0x90, 0xe7, 0x0d, 0xfc, 0xa5, + 0xdf, 0x81, 0xb3, 0x4a, 0x2d, 0xe4, 0xb4, 0x02, 0xe5, 0xbe, 0xcb, 0x7d, 0xa4, 0xd3, 0x48, 0xd2, + 0x49, 0x68, 0x09, 0x59, 0x9d, 0xc2, 0x29, 0x01, 0x79, 0x9b, 0xb1, 0x01, 0x9a, 0xd7, 0x5f, 0x85, + 0xa7, 0x62, 0x6b, 0x08, 0xde, 0x86, 0xf2, 0x88, 0xb1, 0x01, 0x82, 0xd7, 0x92, 0xe0, 0x81, 0x2c, + 0x1e, 0x53, 0xc8, 0xe9, 0x35, 0xa0, 0x21, 0x88, 0xe9, 0x99, 0x5b, 0xd1, 0x5d, 0xd2, 0x77, 0xa0, + 0x3a, 0xb5, 0x8a, 0xe0, 0x37, 0xa1, 0x32, 0x12, 0x2b, 0x08, 0x5f, 0x4f, 0xc1, 0x8b, 0xdd, 0x68, + 0x3c, 0x09, 0x65, 0x67, 0xcb, 0xd5, 0x95, 0x5f, 0x4f, 0xc0, 0x13, 0xc2, 0x36, 0xed, 0x02, 0x4c, + 0xae, 0x0e, 0xbd, 0x98, 0xb4, 0xa5, 0xfe, 0x87, 0x40, 0x7b, 0xfe, 0x40, 0x39, 0x1c, 0x3a, 0x4b, + 0xf4, 0x7d, 0x58, 0x90, 0xeb, 0xf4, 0xb9, 0x7c, 0xbd, 0x08, 0xfe, 0xe2, 0x41, 0x62, 0x12, 0xfd, + 0x73, 0xa8, 0xa9, 0x1e, 0x97, 0x74, 0x39, 0x1f, 0x21, 0x3d, 0x54, 0x68, 0x37, 0x66, 0xd0, 0x90, + 0xe6, 0xbf, 0x21, 0x70, 0x2e, 0xf7, 0x7d, 0x45, 0x5f, 0xcc, 0x87, 0xcd, 0x19, 0x73, 0xb4, 0x97, + 0x0e, 0xa3, 0x2a, 0xa9, 0x75, 0x01, 0x26, 0x1b, 0x19, 0x81, 0x4d, 0x3d, 0x00, 0x32, 0x02, 0x9b, + 0x1e, 0xfd, 0xf4, 0x12, 0xfd, 0x0c, 0xaa, 0x0a, 0x0a, 0xb4, 0xa3, 0x44, 0xc8, 0x7e, 0x73, 0x68, + 0xcb, 0xc5, 0x15, 0xe2, 0x61, 0x57, 0x8d, 0xb6, 0x19, 0x61, 0xcf, 0x99, 0xd8, 0x33, 0xc2, 0x9e, + 0x37, 0x37, 0x63, 0xd8, 0x73, 0x87, 0xbe, 0x8c, 0xb0, 0x17, 0x99, 0x6e, 0x33, 0xc2, 0x5e, 0x68, + 0xc6, 0xd4, 0x4b, 0xb4, 0x0f, 0x27, 0xa7, 0xc6, 0x0d, 0x7a, 0x59, 0x09, 0xa7, 0x9a, 0xfc, 0xb4, + 0x2b, 0x45, 0x44, 0xe3, 0xf1, 0x57, 0x74, 0xdf, 0x8c, 0xf8, 0x67, 0x8f, 0x14, 0xda, 0x72, 0x71, + 0x05, 0x69, 0xfb, 0x13, 0xa0, 0x69, 0x01, 0xda, 0x2e, 0x88, 0x14, 0x59, 0xee, 0x14, 0x96, 0x97, + 0x86, 0x37, 0x61, 0x71, 0xba, 0x75, 0x50, 0xb5, 0xd3, 0x94, 0xbd, 0x4c, 0xbb, 0x5a, 0x48, 0x56, + 0x1a, 0x7b, 0x13, 0xca, 0x41, 0x2b, 0xa1, 0x2d, 0xa5, 0x5a, 0xac, 0x4b, 0x69, 0xe7, 0x73, 0x24, + 0x24, 0xdc, 0x5b, 0x50, 0x09, 0x5b, 0x07, 0xd5, 0xd5, 0xe2, 0xf1, 0xee, 0xa4, 0x5d, 0xc8, 0x95, + 0x89, 0x40, 0xd7, 0x5e, 0xbb, 0xb7, 0xd7, 0x20, 0xf7, 0xf7, 0x1a, 0xe4, 0xef, 0xbd, 0x06, 0xf9, + 0x6a, 0xbf, 0x51, 0xba, 0xbf, 0xdf, 0x28, 0xfd, 0xb9, 0xdf, 0x28, 0xdd, 0xbd, 0x96, 0x3b, 0x76, + 0x7c, 0x2a, 0xff, 0x95, 0x16, 0x03, 0xc8, 0x46, 0x45, 0xfc, 0x29, 0xfd, 0xc2, 0xbf, 0x01, 0x00, + 0x00, 0xff, 0xff, 0x4d, 0x50, 0xb2, 0x10, 0x15, 0x17, 0x00, 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// QueryClient is the client API for Query service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type QueryClient interface { + // Validators queries all validators that match the given status + Validators(ctx context.Context, in *QueryValidatorsRequest, opts ...grpc.CallOption) (*QueryValidatorsResponse, error) + // Validator queries validator info for given validator addr + Validator(ctx context.Context, in *QueryValidatorRequest, opts ...grpc.CallOption) (*QueryValidatorResponse, error) + // ValidatorDelegations queries delegate info for given validator + ValidatorDelegations(ctx context.Context, in *QueryValidatorDelegationsRequest, opts ...grpc.CallOption) (*QueryValidatorDelegationsResponse, error) + // ValidatorUnbondingDelegations queries unbonding delegations of a validator + ValidatorUnbondingDelegations(ctx context.Context, in *QueryValidatorUnbondingDelegationsRequest, opts ...grpc.CallOption) (*QueryValidatorUnbondingDelegationsResponse, error) + // Delegation queries delegate info for given validator delegator pair + Delegation(ctx context.Context, in *QueryDelegationRequest, opts ...grpc.CallOption) (*QueryDelegationResponse, error) + // UnbondingDelegation queries unbonding info for give validator delegator pair + UnbondingDelegation(ctx context.Context, in *QueryUnbondingDelegationRequest, opts ...grpc.CallOption) (*QueryUnbondingDelegationResponse, error) + // DelegatorDelegations queries all delegations of a give delegator address + DelegatorDelegations(ctx context.Context, in *QueryDelegatorDelegationsRequest, opts ...grpc.CallOption) (*QueryDelegatorDelegationsResponse, error) + // DelegatorUnbondingDelegations queries all unbonding delegations of a give delegator address + DelegatorUnbondingDelegations(ctx context.Context, in *QueryDelegatorUnbondingDelegationsRequest, opts ...grpc.CallOption) (*QueryDelegatorUnbondingDelegationsResponse, error) + // Redelegations queries redelegations of given address + Redelegations(ctx context.Context, in *QueryRedelegationsRequest, opts ...grpc.CallOption) (*QueryRedelegationsResponse, error) + // DelegatorValidators queries all validator info for given delegator address + DelegatorValidators(ctx context.Context, in *QueryDelegatorValidatorsRequest, opts ...grpc.CallOption) (*QueryDelegatorValidatorsResponse, error) + // DelegatorValidator queries validator info for given delegator validator pair + DelegatorValidator(ctx context.Context, in *QueryDelegatorValidatorRequest, opts ...grpc.CallOption) (*QueryDelegatorValidatorResponse, error) + // HistoricalInfo queries the historical info for given height + HistoricalInfo(ctx context.Context, in *QueryHistoricalInfoRequest, opts ...grpc.CallOption) (*QueryHistoricalInfoResponse, error) + // Pool queries the pool info + Pool(ctx context.Context, in *QueryPoolRequest, opts ...grpc.CallOption) (*QueryPoolResponse, error) + // Parameters queries the staking parameters + Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error) +} + +type queryClient struct { + cc grpc1.ClientConn +} + +func NewQueryClient(cc grpc1.ClientConn) QueryClient { + return &queryClient{cc} +} + +func (c *queryClient) Validators(ctx context.Context, in *QueryValidatorsRequest, opts ...grpc.CallOption) (*QueryValidatorsResponse, error) { + out := new(QueryValidatorsResponse) + err := c.cc.Invoke(ctx, "/cosmos.staking.Query/Validators", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) Validator(ctx context.Context, in *QueryValidatorRequest, opts ...grpc.CallOption) (*QueryValidatorResponse, error) { + out := new(QueryValidatorResponse) + err := c.cc.Invoke(ctx, "/cosmos.staking.Query/Validator", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) ValidatorDelegations(ctx context.Context, in *QueryValidatorDelegationsRequest, opts ...grpc.CallOption) (*QueryValidatorDelegationsResponse, error) { + out := new(QueryValidatorDelegationsResponse) + err := c.cc.Invoke(ctx, "/cosmos.staking.Query/ValidatorDelegations", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) ValidatorUnbondingDelegations(ctx context.Context, in *QueryValidatorUnbondingDelegationsRequest, opts ...grpc.CallOption) (*QueryValidatorUnbondingDelegationsResponse, error) { + out := new(QueryValidatorUnbondingDelegationsResponse) + err := c.cc.Invoke(ctx, "/cosmos.staking.Query/ValidatorUnbondingDelegations", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) Delegation(ctx context.Context, in *QueryDelegationRequest, opts ...grpc.CallOption) (*QueryDelegationResponse, error) { + out := new(QueryDelegationResponse) + err := c.cc.Invoke(ctx, "/cosmos.staking.Query/Delegation", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) UnbondingDelegation(ctx context.Context, in *QueryUnbondingDelegationRequest, opts ...grpc.CallOption) (*QueryUnbondingDelegationResponse, error) { + out := new(QueryUnbondingDelegationResponse) + err := c.cc.Invoke(ctx, "/cosmos.staking.Query/UnbondingDelegation", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) DelegatorDelegations(ctx context.Context, in *QueryDelegatorDelegationsRequest, opts ...grpc.CallOption) (*QueryDelegatorDelegationsResponse, error) { + out := new(QueryDelegatorDelegationsResponse) + err := c.cc.Invoke(ctx, "/cosmos.staking.Query/DelegatorDelegations", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) DelegatorUnbondingDelegations(ctx context.Context, in *QueryDelegatorUnbondingDelegationsRequest, opts ...grpc.CallOption) (*QueryDelegatorUnbondingDelegationsResponse, error) { + out := new(QueryDelegatorUnbondingDelegationsResponse) + err := c.cc.Invoke(ctx, "/cosmos.staking.Query/DelegatorUnbondingDelegations", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) Redelegations(ctx context.Context, in *QueryRedelegationsRequest, opts ...grpc.CallOption) (*QueryRedelegationsResponse, error) { + out := new(QueryRedelegationsResponse) + err := c.cc.Invoke(ctx, "/cosmos.staking.Query/Redelegations", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) DelegatorValidators(ctx context.Context, in *QueryDelegatorValidatorsRequest, opts ...grpc.CallOption) (*QueryDelegatorValidatorsResponse, error) { + out := new(QueryDelegatorValidatorsResponse) + err := c.cc.Invoke(ctx, "/cosmos.staking.Query/DelegatorValidators", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) DelegatorValidator(ctx context.Context, in *QueryDelegatorValidatorRequest, opts ...grpc.CallOption) (*QueryDelegatorValidatorResponse, error) { + out := new(QueryDelegatorValidatorResponse) + err := c.cc.Invoke(ctx, "/cosmos.staking.Query/DelegatorValidator", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) HistoricalInfo(ctx context.Context, in *QueryHistoricalInfoRequest, opts ...grpc.CallOption) (*QueryHistoricalInfoResponse, error) { + out := new(QueryHistoricalInfoResponse) + err := c.cc.Invoke(ctx, "/cosmos.staking.Query/HistoricalInfo", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) Pool(ctx context.Context, in *QueryPoolRequest, opts ...grpc.CallOption) (*QueryPoolResponse, error) { + out := new(QueryPoolResponse) + err := c.cc.Invoke(ctx, "/cosmos.staking.Query/Pool", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error) { + out := new(QueryParamsResponse) + err := c.cc.Invoke(ctx, "/cosmos.staking.Query/Params", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// QueryServer is the server API for Query service. +type QueryServer interface { + // Validators queries all validators that match the given status + Validators(context.Context, *QueryValidatorsRequest) (*QueryValidatorsResponse, error) + // Validator queries validator info for given validator addr + Validator(context.Context, *QueryValidatorRequest) (*QueryValidatorResponse, error) + // ValidatorDelegations queries delegate info for given validator + ValidatorDelegations(context.Context, *QueryValidatorDelegationsRequest) (*QueryValidatorDelegationsResponse, error) + // ValidatorUnbondingDelegations queries unbonding delegations of a validator + ValidatorUnbondingDelegations(context.Context, *QueryValidatorUnbondingDelegationsRequest) (*QueryValidatorUnbondingDelegationsResponse, error) + // Delegation queries delegate info for given validator delegator pair + Delegation(context.Context, *QueryDelegationRequest) (*QueryDelegationResponse, error) + // UnbondingDelegation queries unbonding info for give validator delegator pair + UnbondingDelegation(context.Context, *QueryUnbondingDelegationRequest) (*QueryUnbondingDelegationResponse, error) + // DelegatorDelegations queries all delegations of a give delegator address + DelegatorDelegations(context.Context, *QueryDelegatorDelegationsRequest) (*QueryDelegatorDelegationsResponse, error) + // DelegatorUnbondingDelegations queries all unbonding delegations of a give delegator address + DelegatorUnbondingDelegations(context.Context, *QueryDelegatorUnbondingDelegationsRequest) (*QueryDelegatorUnbondingDelegationsResponse, error) + // Redelegations queries redelegations of given address + Redelegations(context.Context, *QueryRedelegationsRequest) (*QueryRedelegationsResponse, error) + // DelegatorValidators queries all validator info for given delegator address + DelegatorValidators(context.Context, *QueryDelegatorValidatorsRequest) (*QueryDelegatorValidatorsResponse, error) + // DelegatorValidator queries validator info for given delegator validator pair + DelegatorValidator(context.Context, *QueryDelegatorValidatorRequest) (*QueryDelegatorValidatorResponse, error) + // HistoricalInfo queries the historical info for given height + HistoricalInfo(context.Context, *QueryHistoricalInfoRequest) (*QueryHistoricalInfoResponse, error) + // Pool queries the pool info + Pool(context.Context, *QueryPoolRequest) (*QueryPoolResponse, error) + // Parameters queries the staking parameters + Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error) +} + +// UnimplementedQueryServer can be embedded to have forward compatible implementations. +type UnimplementedQueryServer struct { +} + +func (*UnimplementedQueryServer) Validators(ctx context.Context, req *QueryValidatorsRequest) (*QueryValidatorsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Validators not implemented") +} +func (*UnimplementedQueryServer) Validator(ctx context.Context, req *QueryValidatorRequest) (*QueryValidatorResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Validator not implemented") +} +func (*UnimplementedQueryServer) ValidatorDelegations(ctx context.Context, req *QueryValidatorDelegationsRequest) (*QueryValidatorDelegationsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ValidatorDelegations not implemented") +} +func (*UnimplementedQueryServer) ValidatorUnbondingDelegations(ctx context.Context, req *QueryValidatorUnbondingDelegationsRequest) (*QueryValidatorUnbondingDelegationsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ValidatorUnbondingDelegations not implemented") +} +func (*UnimplementedQueryServer) Delegation(ctx context.Context, req *QueryDelegationRequest) (*QueryDelegationResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Delegation not implemented") +} +func (*UnimplementedQueryServer) UnbondingDelegation(ctx context.Context, req *QueryUnbondingDelegationRequest) (*QueryUnbondingDelegationResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method UnbondingDelegation not implemented") +} +func (*UnimplementedQueryServer) DelegatorDelegations(ctx context.Context, req *QueryDelegatorDelegationsRequest) (*QueryDelegatorDelegationsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method DelegatorDelegations not implemented") +} +func (*UnimplementedQueryServer) DelegatorUnbondingDelegations(ctx context.Context, req *QueryDelegatorUnbondingDelegationsRequest) (*QueryDelegatorUnbondingDelegationsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method DelegatorUnbondingDelegations not implemented") +} +func (*UnimplementedQueryServer) Redelegations(ctx context.Context, req *QueryRedelegationsRequest) (*QueryRedelegationsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Redelegations not implemented") +} +func (*UnimplementedQueryServer) DelegatorValidators(ctx context.Context, req *QueryDelegatorValidatorsRequest) (*QueryDelegatorValidatorsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method DelegatorValidators not implemented") +} +func (*UnimplementedQueryServer) DelegatorValidator(ctx context.Context, req *QueryDelegatorValidatorRequest) (*QueryDelegatorValidatorResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method DelegatorValidator not implemented") +} +func (*UnimplementedQueryServer) HistoricalInfo(ctx context.Context, req *QueryHistoricalInfoRequest) (*QueryHistoricalInfoResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method HistoricalInfo not implemented") +} +func (*UnimplementedQueryServer) Pool(ctx context.Context, req *QueryPoolRequest) (*QueryPoolResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Pool not implemented") +} +func (*UnimplementedQueryServer) Params(ctx context.Context, req *QueryParamsRequest) (*QueryParamsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Params not implemented") +} + +func RegisterQueryServer(s grpc1.Server, srv QueryServer) { + s.RegisterService(&_Query_serviceDesc, srv) +} + +func _Query_Validators_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryValidatorsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).Validators(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmos.staking.Query/Validators", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).Validators(ctx, req.(*QueryValidatorsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_Validator_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryValidatorRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).Validator(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmos.staking.Query/Validator", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).Validator(ctx, req.(*QueryValidatorRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_ValidatorDelegations_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryValidatorDelegationsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).ValidatorDelegations(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmos.staking.Query/ValidatorDelegations", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).ValidatorDelegations(ctx, req.(*QueryValidatorDelegationsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_ValidatorUnbondingDelegations_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryValidatorUnbondingDelegationsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).ValidatorUnbondingDelegations(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmos.staking.Query/ValidatorUnbondingDelegations", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).ValidatorUnbondingDelegations(ctx, req.(*QueryValidatorUnbondingDelegationsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_Delegation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryDelegationRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).Delegation(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmos.staking.Query/Delegation", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).Delegation(ctx, req.(*QueryDelegationRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_UnbondingDelegation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryUnbondingDelegationRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).UnbondingDelegation(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmos.staking.Query/UnbondingDelegation", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).UnbondingDelegation(ctx, req.(*QueryUnbondingDelegationRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_DelegatorDelegations_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryDelegatorDelegationsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).DelegatorDelegations(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmos.staking.Query/DelegatorDelegations", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).DelegatorDelegations(ctx, req.(*QueryDelegatorDelegationsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_DelegatorUnbondingDelegations_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryDelegatorUnbondingDelegationsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).DelegatorUnbondingDelegations(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmos.staking.Query/DelegatorUnbondingDelegations", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).DelegatorUnbondingDelegations(ctx, req.(*QueryDelegatorUnbondingDelegationsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_Redelegations_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryRedelegationsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).Redelegations(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmos.staking.Query/Redelegations", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).Redelegations(ctx, req.(*QueryRedelegationsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_DelegatorValidators_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryDelegatorValidatorsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).DelegatorValidators(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmos.staking.Query/DelegatorValidators", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).DelegatorValidators(ctx, req.(*QueryDelegatorValidatorsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_DelegatorValidator_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryDelegatorValidatorRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).DelegatorValidator(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmos.staking.Query/DelegatorValidator", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).DelegatorValidator(ctx, req.(*QueryDelegatorValidatorRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_HistoricalInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryHistoricalInfoRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).HistoricalInfo(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmos.staking.Query/HistoricalInfo", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).HistoricalInfo(ctx, req.(*QueryHistoricalInfoRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_Pool_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryPoolRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).Pool(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmos.staking.Query/Pool", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).Pool(ctx, req.(*QueryPoolRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_Params_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryParamsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).Params(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmos.staking.Query/Params", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).Params(ctx, req.(*QueryParamsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _Query_serviceDesc = grpc.ServiceDesc{ + ServiceName: "cosmos.staking.Query", + HandlerType: (*QueryServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "Validators", + Handler: _Query_Validators_Handler, + }, + { + MethodName: "Validator", + Handler: _Query_Validator_Handler, + }, + { + MethodName: "ValidatorDelegations", + Handler: _Query_ValidatorDelegations_Handler, + }, + { + MethodName: "ValidatorUnbondingDelegations", + Handler: _Query_ValidatorUnbondingDelegations_Handler, + }, + { + MethodName: "Delegation", + Handler: _Query_Delegation_Handler, + }, + { + MethodName: "UnbondingDelegation", + Handler: _Query_UnbondingDelegation_Handler, + }, + { + MethodName: "DelegatorDelegations", + Handler: _Query_DelegatorDelegations_Handler, + }, + { + MethodName: "DelegatorUnbondingDelegations", + Handler: _Query_DelegatorUnbondingDelegations_Handler, + }, + { + MethodName: "Redelegations", + Handler: _Query_Redelegations_Handler, + }, + { + MethodName: "DelegatorValidators", + Handler: _Query_DelegatorValidators_Handler, + }, + { + MethodName: "DelegatorValidator", + Handler: _Query_DelegatorValidator_Handler, + }, + { + MethodName: "HistoricalInfo", + Handler: _Query_HistoricalInfo_Handler, + }, + { + MethodName: "Pool", + Handler: _Query_Pool_Handler, + }, + { + MethodName: "Params", + Handler: _Query_Params_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "cosmos/staking/query.proto", +} + +func (m *QueryValidatorsRequest) 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 *QueryValidatorsRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryValidatorsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Req != nil { + { + size, err := m.Req.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.Status) > 0 { + i -= len(m.Status) + copy(dAtA[i:], m.Status) + i = encodeVarintQuery(dAtA, i, uint64(len(m.Status))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryValidatorsResponse) 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 *QueryValidatorsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryValidatorsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Res != nil { + { + size, err := m.Res.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.Validators) > 0 { + for iNdEx := len(m.Validators) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Validators[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *QueryValidatorRequest) 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 *QueryValidatorRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryValidatorRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.ValidatorAddr) > 0 { + i -= len(m.ValidatorAddr) + copy(dAtA[i:], m.ValidatorAddr) + i = encodeVarintQuery(dAtA, i, uint64(len(m.ValidatorAddr))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryValidatorResponse) 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 *QueryValidatorResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryValidatorResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Validator.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *QueryValidatorDelegationsRequest) 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 *QueryValidatorDelegationsRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryValidatorDelegationsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Req != nil { + { + size, err := m.Req.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.ValidatorAddr) > 0 { + i -= len(m.ValidatorAddr) + copy(dAtA[i:], m.ValidatorAddr) + i = encodeVarintQuery(dAtA, i, uint64(len(m.ValidatorAddr))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryValidatorDelegationsResponse) 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 *QueryValidatorDelegationsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryValidatorDelegationsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Res != nil { + { + size, err := m.Res.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.DelegationResponses) > 0 { + for iNdEx := len(m.DelegationResponses) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.DelegationResponses[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *QueryValidatorUnbondingDelegationsRequest) 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 *QueryValidatorUnbondingDelegationsRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryValidatorUnbondingDelegationsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Req != nil { + { + size, err := m.Req.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.ValidatorAddr) > 0 { + i -= len(m.ValidatorAddr) + copy(dAtA[i:], m.ValidatorAddr) + i = encodeVarintQuery(dAtA, i, uint64(len(m.ValidatorAddr))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryValidatorUnbondingDelegationsResponse) 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 *QueryValidatorUnbondingDelegationsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryValidatorUnbondingDelegationsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Res != nil { + { + size, err := m.Res.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.UnbondingResponses) > 0 { + for iNdEx := len(m.UnbondingResponses) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.UnbondingResponses[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *QueryDelegationRequest) 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 *QueryDelegationRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryDelegationRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.ValidatorAddr) > 0 { + i -= len(m.ValidatorAddr) + copy(dAtA[i:], m.ValidatorAddr) + i = encodeVarintQuery(dAtA, i, uint64(len(m.ValidatorAddr))) + i-- + dAtA[i] = 0x12 + } + if len(m.DelegatorAddr) > 0 { + i -= len(m.DelegatorAddr) + copy(dAtA[i:], m.DelegatorAddr) + i = encodeVarintQuery(dAtA, i, uint64(len(m.DelegatorAddr))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryDelegationResponse) 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 *QueryDelegationResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryDelegationResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.DelegationResponse != nil { + { + size, err := m.DelegationResponse.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryUnbondingDelegationRequest) 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 *QueryUnbondingDelegationRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryUnbondingDelegationRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.ValidatorAddr) > 0 { + i -= len(m.ValidatorAddr) + copy(dAtA[i:], m.ValidatorAddr) + i = encodeVarintQuery(dAtA, i, uint64(len(m.ValidatorAddr))) + i-- + dAtA[i] = 0x12 + } + if len(m.DelegatorAddr) > 0 { + i -= len(m.DelegatorAddr) + copy(dAtA[i:], m.DelegatorAddr) + i = encodeVarintQuery(dAtA, i, uint64(len(m.DelegatorAddr))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryUnbondingDelegationResponse) 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 *QueryUnbondingDelegationResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryUnbondingDelegationResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Unbond.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *QueryDelegatorDelegationsRequest) 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 *QueryDelegatorDelegationsRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryDelegatorDelegationsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Req != nil { + { + size, err := m.Req.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.DelegatorAddr) > 0 { + i -= len(m.DelegatorAddr) + copy(dAtA[i:], m.DelegatorAddr) + i = encodeVarintQuery(dAtA, i, uint64(len(m.DelegatorAddr))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryDelegatorDelegationsResponse) 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 *QueryDelegatorDelegationsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryDelegatorDelegationsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Res != nil { + { + size, err := m.Res.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.DelegationResponses) > 0 { + for iNdEx := len(m.DelegationResponses) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.DelegationResponses[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *QueryDelegatorUnbondingDelegationsRequest) 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 *QueryDelegatorUnbondingDelegationsRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryDelegatorUnbondingDelegationsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Req != nil { + { + size, err := m.Req.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.DelegatorAddr) > 0 { + i -= len(m.DelegatorAddr) + copy(dAtA[i:], m.DelegatorAddr) + i = encodeVarintQuery(dAtA, i, uint64(len(m.DelegatorAddr))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryDelegatorUnbondingDelegationsResponse) 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 *QueryDelegatorUnbondingDelegationsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryDelegatorUnbondingDelegationsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Res != nil { + { + size, err := m.Res.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.UnbondingResponses) > 0 { + for iNdEx := len(m.UnbondingResponses) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.UnbondingResponses[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *QueryRedelegationsRequest) 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 *QueryRedelegationsRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryRedelegationsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Req != nil { + { + size, err := m.Req.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + if len(m.DstValidatorAddr) > 0 { + i -= len(m.DstValidatorAddr) + copy(dAtA[i:], m.DstValidatorAddr) + i = encodeVarintQuery(dAtA, i, uint64(len(m.DstValidatorAddr))) + i-- + dAtA[i] = 0x1a + } + if len(m.SrcValidatorAddr) > 0 { + i -= len(m.SrcValidatorAddr) + copy(dAtA[i:], m.SrcValidatorAddr) + i = encodeVarintQuery(dAtA, i, uint64(len(m.SrcValidatorAddr))) + i-- + dAtA[i] = 0x12 + } + if len(m.DelegatorAddr) > 0 { + i -= len(m.DelegatorAddr) + copy(dAtA[i:], m.DelegatorAddr) + i = encodeVarintQuery(dAtA, i, uint64(len(m.DelegatorAddr))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryRedelegationsResponse) 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 *QueryRedelegationsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryRedelegationsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Res != nil { + { + size, err := m.Res.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.RedelegationResponses) > 0 { + for iNdEx := len(m.RedelegationResponses) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.RedelegationResponses[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *QueryDelegatorValidatorsRequest) 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 *QueryDelegatorValidatorsRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryDelegatorValidatorsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Req != nil { + { + size, err := m.Req.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.DelegatorAddr) > 0 { + i -= len(m.DelegatorAddr) + copy(dAtA[i:], m.DelegatorAddr) + i = encodeVarintQuery(dAtA, i, uint64(len(m.DelegatorAddr))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryDelegatorValidatorsResponse) 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 *QueryDelegatorValidatorsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryDelegatorValidatorsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Res != nil { + { + size, err := m.Res.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.Validators) > 0 { + for iNdEx := len(m.Validators) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Validators[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *QueryDelegatorValidatorRequest) 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 *QueryDelegatorValidatorRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryDelegatorValidatorRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.ValidatorAddr) > 0 { + i -= len(m.ValidatorAddr) + copy(dAtA[i:], m.ValidatorAddr) + i = encodeVarintQuery(dAtA, i, uint64(len(m.ValidatorAddr))) + i-- + dAtA[i] = 0x12 + } + if len(m.DelegatorAddr) > 0 { + i -= len(m.DelegatorAddr) + copy(dAtA[i:], m.DelegatorAddr) + i = encodeVarintQuery(dAtA, i, uint64(len(m.DelegatorAddr))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryDelegatorValidatorResponse) 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 *QueryDelegatorValidatorResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryDelegatorValidatorResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Validator.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *QueryHistoricalInfoRequest) 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 *QueryHistoricalInfoRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryHistoricalInfoRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Height != 0 { + i = encodeVarintQuery(dAtA, i, uint64(m.Height)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *QueryHistoricalInfoResponse) 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 *QueryHistoricalInfoResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryHistoricalInfoResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Hist != nil { + { + size, err := m.Hist.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryPoolRequest) 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 *QueryPoolRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryPoolRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *QueryPoolResponse) 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 *QueryPoolResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryPoolResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Pool.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *QueryParamsRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *QueryParamsRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryParamsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *QueryParamsResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *QueryParamsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryParamsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Res != nil { + { + size, err := m.Res.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 { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func encodeVarintQuery(dAtA []byte, offset int, v uint64) int { + offset -= sovQuery(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *QueryValidatorsRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Status) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + if m.Req != nil { + l = m.Req.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryValidatorsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Validators) > 0 { + for _, e := range m.Validators { + l = e.Size() + n += 1 + l + sovQuery(uint64(l)) + } + } + if m.Res != nil { + l = m.Res.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryValidatorRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ValidatorAddr) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryValidatorResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Validator.Size() + n += 1 + l + sovQuery(uint64(l)) + return n +} + +func (m *QueryValidatorDelegationsRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ValidatorAddr) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + if m.Req != nil { + l = m.Req.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryValidatorDelegationsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.DelegationResponses) > 0 { + for _, e := range m.DelegationResponses { + l = e.Size() + n += 1 + l + sovQuery(uint64(l)) + } + } + if m.Res != nil { + l = m.Res.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryValidatorUnbondingDelegationsRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ValidatorAddr) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + if m.Req != nil { + l = m.Req.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryValidatorUnbondingDelegationsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.UnbondingResponses) > 0 { + for _, e := range m.UnbondingResponses { + l = e.Size() + n += 1 + l + sovQuery(uint64(l)) + } + } + if m.Res != nil { + l = m.Res.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryDelegationRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.DelegatorAddr) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + l = len(m.ValidatorAddr) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryDelegationResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.DelegationResponse != nil { + l = m.DelegationResponse.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryUnbondingDelegationRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.DelegatorAddr) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + l = len(m.ValidatorAddr) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryUnbondingDelegationResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Unbond.Size() + n += 1 + l + sovQuery(uint64(l)) + return n +} + +func (m *QueryDelegatorDelegationsRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.DelegatorAddr) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + if m.Req != nil { + l = m.Req.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryDelegatorDelegationsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.DelegationResponses) > 0 { + for _, e := range m.DelegationResponses { + l = e.Size() + n += 1 + l + sovQuery(uint64(l)) + } + } + if m.Res != nil { + l = m.Res.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryDelegatorUnbondingDelegationsRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.DelegatorAddr) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + if m.Req != nil { + l = m.Req.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryDelegatorUnbondingDelegationsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.UnbondingResponses) > 0 { + for _, e := range m.UnbondingResponses { + l = e.Size() + n += 1 + l + sovQuery(uint64(l)) + } + } + if m.Res != nil { + l = m.Res.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryRedelegationsRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.DelegatorAddr) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + l = len(m.SrcValidatorAddr) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + l = len(m.DstValidatorAddr) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + if m.Req != nil { + l = m.Req.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryRedelegationsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.RedelegationResponses) > 0 { + for _, e := range m.RedelegationResponses { + l = e.Size() + n += 1 + l + sovQuery(uint64(l)) + } + } + if m.Res != nil { + l = m.Res.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryDelegatorValidatorsRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.DelegatorAddr) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + if m.Req != nil { + l = m.Req.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryDelegatorValidatorsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Validators) > 0 { + for _, e := range m.Validators { + l = e.Size() + n += 1 + l + sovQuery(uint64(l)) + } + } + if m.Res != nil { + l = m.Res.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryDelegatorValidatorRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.DelegatorAddr) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + l = len(m.ValidatorAddr) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryDelegatorValidatorResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Validator.Size() + n += 1 + l + sovQuery(uint64(l)) + return n +} + +func (m *QueryHistoricalInfoRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Height != 0 { + n += 1 + sovQuery(uint64(m.Height)) + } + return n +} + +func (m *QueryHistoricalInfoResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Hist != nil { + l = m.Hist.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryPoolRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *QueryPoolResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Pool.Size() + n += 1 + l + sovQuery(uint64(l)) + return n +} + +func (m *QueryParamsRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *QueryParamsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Params.Size() + n += 1 + l + sovQuery(uint64(l)) + if m.Res != nil { + l = m.Res.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func sovQuery(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozQuery(x uint64) (n int) { + return sovQuery(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *QueryValidatorsRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryValidatorsRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryValidatorsRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Status = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Req", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Req == nil { + m.Req = &query.PageRequest{} + } + if err := m.Req.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryValidatorsResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryValidatorsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryValidatorsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Validators", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Validators = append(m.Validators, Validator{}) + if err := m.Validators[len(m.Validators)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Res", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Res == nil { + m.Res = &query.PageResponse{} + } + if err := m.Res.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryValidatorRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryValidatorRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryValidatorRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddr", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ValidatorAddr = append(m.ValidatorAddr[:0], dAtA[iNdEx:postIndex]...) + if m.ValidatorAddr == nil { + m.ValidatorAddr = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryValidatorResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryValidatorResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryValidatorResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Validator", 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.Validator.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryValidatorDelegationsRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryValidatorDelegationsRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryValidatorDelegationsRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddr", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ValidatorAddr = append(m.ValidatorAddr[:0], dAtA[iNdEx:postIndex]...) + if m.ValidatorAddr == nil { + m.ValidatorAddr = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Req", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Req == nil { + m.Req = &query.PageRequest{} + } + if err := m.Req.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryValidatorDelegationsResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryValidatorDelegationsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryValidatorDelegationsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DelegationResponses", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DelegationResponses = append(m.DelegationResponses, DelegationResponse{}) + if err := m.DelegationResponses[len(m.DelegationResponses)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Res", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Res == nil { + m.Res = &query.PageResponse{} + } + if err := m.Res.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryValidatorUnbondingDelegationsRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryValidatorUnbondingDelegationsRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryValidatorUnbondingDelegationsRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddr", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ValidatorAddr = append(m.ValidatorAddr[:0], dAtA[iNdEx:postIndex]...) + if m.ValidatorAddr == nil { + m.ValidatorAddr = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Req", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Req == nil { + m.Req = &query.PageRequest{} + } + if err := m.Req.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryValidatorUnbondingDelegationsResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryValidatorUnbondingDelegationsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryValidatorUnbondingDelegationsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field UnbondingResponses", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.UnbondingResponses = append(m.UnbondingResponses, UnbondingDelegation{}) + if err := m.UnbondingResponses[len(m.UnbondingResponses)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Res", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Res == nil { + m.Res = &query.PageResponse{} + } + if err := m.Res.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryDelegationRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryDelegationRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryDelegationRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddr", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DelegatorAddr = append(m.DelegatorAddr[:0], dAtA[iNdEx:postIndex]...) + if m.DelegatorAddr == nil { + m.DelegatorAddr = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddr", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ValidatorAddr = append(m.ValidatorAddr[:0], dAtA[iNdEx:postIndex]...) + if m.ValidatorAddr == nil { + m.ValidatorAddr = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryDelegationResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryDelegationResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryDelegationResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DelegationResponse", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.DelegationResponse == nil { + m.DelegationResponse = &DelegationResponse{} + } + if err := m.DelegationResponse.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryUnbondingDelegationRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryUnbondingDelegationRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryUnbondingDelegationRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddr", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DelegatorAddr = append(m.DelegatorAddr[:0], dAtA[iNdEx:postIndex]...) + if m.DelegatorAddr == nil { + m.DelegatorAddr = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddr", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ValidatorAddr = append(m.ValidatorAddr[:0], dAtA[iNdEx:postIndex]...) + if m.ValidatorAddr == nil { + m.ValidatorAddr = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryUnbondingDelegationResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryUnbondingDelegationResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryUnbondingDelegationResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Unbond", 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.Unbond.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryDelegatorDelegationsRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryDelegatorDelegationsRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryDelegatorDelegationsRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddr", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DelegatorAddr = append(m.DelegatorAddr[:0], dAtA[iNdEx:postIndex]...) + if m.DelegatorAddr == nil { + m.DelegatorAddr = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Req", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Req == nil { + m.Req = &query.PageRequest{} + } + if err := m.Req.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryDelegatorDelegationsResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryDelegatorDelegationsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryDelegatorDelegationsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DelegationResponses", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DelegationResponses = append(m.DelegationResponses, DelegationResponse{}) + if err := m.DelegationResponses[len(m.DelegationResponses)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Res", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Res == nil { + m.Res = &query.PageResponse{} + } + if err := m.Res.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryDelegatorUnbondingDelegationsRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryDelegatorUnbondingDelegationsRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryDelegatorUnbondingDelegationsRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddr", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DelegatorAddr = append(m.DelegatorAddr[:0], dAtA[iNdEx:postIndex]...) + if m.DelegatorAddr == nil { + m.DelegatorAddr = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Req", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Req == nil { + m.Req = &query.PageRequest{} + } + if err := m.Req.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryDelegatorUnbondingDelegationsResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryDelegatorUnbondingDelegationsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryDelegatorUnbondingDelegationsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field UnbondingResponses", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.UnbondingResponses = append(m.UnbondingResponses, UnbondingDelegation{}) + if err := m.UnbondingResponses[len(m.UnbondingResponses)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Res", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Res == nil { + m.Res = &query.PageResponse{} + } + if err := m.Res.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryRedelegationsRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryRedelegationsRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryRedelegationsRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddr", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DelegatorAddr = append(m.DelegatorAddr[:0], dAtA[iNdEx:postIndex]...) + if m.DelegatorAddr == nil { + m.DelegatorAddr = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SrcValidatorAddr", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SrcValidatorAddr = append(m.SrcValidatorAddr[:0], dAtA[iNdEx:postIndex]...) + if m.SrcValidatorAddr == nil { + m.SrcValidatorAddr = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DstValidatorAddr", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DstValidatorAddr = append(m.DstValidatorAddr[:0], dAtA[iNdEx:postIndex]...) + if m.DstValidatorAddr == nil { + m.DstValidatorAddr = []byte{} + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Req", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Req == nil { + m.Req = &query.PageRequest{} + } + if err := m.Req.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryRedelegationsResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryRedelegationsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryRedelegationsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RedelegationResponses", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RedelegationResponses = append(m.RedelegationResponses, RedelegationResponse{}) + if err := m.RedelegationResponses[len(m.RedelegationResponses)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Res", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Res == nil { + m.Res = &query.PageResponse{} + } + if err := m.Res.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryDelegatorValidatorsRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryDelegatorValidatorsRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryDelegatorValidatorsRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddr", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DelegatorAddr = append(m.DelegatorAddr[:0], dAtA[iNdEx:postIndex]...) + if m.DelegatorAddr == nil { + m.DelegatorAddr = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Req", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Req == nil { + m.Req = &query.PageRequest{} + } + if err := m.Req.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryDelegatorValidatorsResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryDelegatorValidatorsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryDelegatorValidatorsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Validators", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Validators = append(m.Validators, Validator{}) + if err := m.Validators[len(m.Validators)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Res", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Res == nil { + m.Res = &query.PageResponse{} + } + if err := m.Res.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryDelegatorValidatorRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryDelegatorValidatorRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryDelegatorValidatorRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddr", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DelegatorAddr = append(m.DelegatorAddr[:0], dAtA[iNdEx:postIndex]...) + if m.DelegatorAddr == nil { + m.DelegatorAddr = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddr", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ValidatorAddr = append(m.ValidatorAddr[:0], dAtA[iNdEx:postIndex]...) + if m.ValidatorAddr == nil { + m.ValidatorAddr = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryDelegatorValidatorResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryDelegatorValidatorResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryDelegatorValidatorResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Validator", 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.Validator.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryHistoricalInfoRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryHistoricalInfoRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryHistoricalInfoRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) + } + m.Height = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Height |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryHistoricalInfoResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryHistoricalInfoResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryHistoricalInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Hist", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Hist == nil { + m.Hist = &HistoricalInfo{} + } + if err := m.Hist.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryPoolRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryPoolRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryPoolRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryPoolResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryPoolResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryPoolResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pool", 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.Pool.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryParamsRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryParamsRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryParamsRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryParamsResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryParamsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryParamsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Res", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Res == nil { + m.Res = &query.PageResponse{} + } + if err := m.Res.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipQuery(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowQuery + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowQuery + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowQuery + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthQuery + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupQuery + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthQuery + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthQuery = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowQuery = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupQuery = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/staking/types/staking.pb.go b/x/staking/types/staking.pb.go index 3a473a7d70ff..3eca31a9cfe9 100644 --- a/x/staking/types/staking.pb.go +++ b/x/staking/types/staking.pb.go @@ -5,16 +5,20 @@ package types import ( bytes "bytes" + compress_gzip "compress/gzip" fmt "fmt" github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" types "github.com/cosmos/cosmos-sdk/types" _ "github.com/gogo/protobuf/gogoproto" + github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto" proto "github.com/gogo/protobuf/proto" + github_com_gogo_protobuf_protoc_gen_gogo_descriptor "github.com/gogo/protobuf/protoc-gen-gogo/descriptor" github_com_gogo_protobuf_types "github.com/gogo/protobuf/types" _ "github.com/golang/protobuf/ptypes/duration" _ "github.com/golang/protobuf/ptypes/timestamp" types1 "github.com/tendermint/tendermint/abci/types" io "io" + io_ioutil "io/ioutil" math "math" math_bits "math/bits" time "time" @@ -1216,6 +1220,201 @@ func (m *Params) GetBondDenom() string { return "" } +// DelegationResponse is equivalent to Delegation except that it contains a balance +// in addition to shares which is more suitable for client responses. +type DelegationResponse struct { + Delegation Delegation `protobuf:"bytes,1,opt,name=delegation,proto3" json:"delegation"` + Balance types.Coin `protobuf:"bytes,2,opt,name=balance,proto3" json:"balance"` +} + +func (m *DelegationResponse) Reset() { *m = DelegationResponse{} } +func (*DelegationResponse) ProtoMessage() {} +func (*DelegationResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_146003fcdb99b683, []int{20} +} +func (m *DelegationResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DelegationResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_DelegationResponse.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 *DelegationResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_DelegationResponse.Merge(m, src) +} +func (m *DelegationResponse) XXX_Size() int { + return m.Size() +} +func (m *DelegationResponse) XXX_DiscardUnknown() { + xxx_messageInfo_DelegationResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_DelegationResponse proto.InternalMessageInfo + +func (m *DelegationResponse) GetDelegation() Delegation { + if m != nil { + return m.Delegation + } + return Delegation{} +} + +func (m *DelegationResponse) GetBalance() types.Coin { + if m != nil { + return m.Balance + } + return types.Coin{} +} + +// RedelegationEntryResponse is equivalent to a RedelegationEntry except that it +// contains a balance in addition to shares which is more suitable for client +// responses. +type RedelegationEntryResponse struct { + RedelegationEntry RedelegationEntry `protobuf:"bytes,1,opt,name=redelegation_entry,json=redelegationEntry,proto3" json:"redelegation_entry"` + Balance github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,4,opt,name=balance,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"balance"` +} + +func (m *RedelegationEntryResponse) Reset() { *m = RedelegationEntryResponse{} } +func (m *RedelegationEntryResponse) String() string { return proto.CompactTextString(m) } +func (*RedelegationEntryResponse) ProtoMessage() {} +func (*RedelegationEntryResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_146003fcdb99b683, []int{21} +} +func (m *RedelegationEntryResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RedelegationEntryResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RedelegationEntryResponse.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 *RedelegationEntryResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_RedelegationEntryResponse.Merge(m, src) +} +func (m *RedelegationEntryResponse) XXX_Size() int { + return m.Size() +} +func (m *RedelegationEntryResponse) XXX_DiscardUnknown() { + xxx_messageInfo_RedelegationEntryResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_RedelegationEntryResponse proto.InternalMessageInfo + +func (m *RedelegationEntryResponse) GetRedelegationEntry() RedelegationEntry { + if m != nil { + return m.RedelegationEntry + } + return RedelegationEntry{} +} + +// RedelegationResponse is equivalent to a Redelegation except that its entries +// contain a balance in addition to shares which is more suitable for client +// responses. +type RedelegationResponse struct { + Redelegation Redelegation `protobuf:"bytes,1,opt,name=redelegation,proto3" json:"redelegation"` + Entries []RedelegationEntryResponse `protobuf:"bytes,2,rep,name=entries,proto3" json:"entries"` +} + +func (m *RedelegationResponse) Reset() { *m = RedelegationResponse{} } +func (m *RedelegationResponse) String() string { return proto.CompactTextString(m) } +func (*RedelegationResponse) ProtoMessage() {} +func (*RedelegationResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_146003fcdb99b683, []int{22} +} +func (m *RedelegationResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RedelegationResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RedelegationResponse.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 *RedelegationResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_RedelegationResponse.Merge(m, src) +} +func (m *RedelegationResponse) XXX_Size() int { + return m.Size() +} +func (m *RedelegationResponse) XXX_DiscardUnknown() { + xxx_messageInfo_RedelegationResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_RedelegationResponse proto.InternalMessageInfo + +func (m *RedelegationResponse) GetRedelegation() Redelegation { + if m != nil { + return m.Redelegation + } + return Redelegation{} +} + +func (m *RedelegationResponse) GetEntries() []RedelegationEntryResponse { + if m != nil { + return m.Entries + } + return nil +} + +// Pool - tracking bonded and not-bonded token supply of the bond denomination +type Pool struct { + NotBondedTokens github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,1,opt,name=not_bonded_tokens,json=notBondedTokens,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"not_bonded_tokens"` + BondedTokens github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=bonded_tokens,json=bondedTokens,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"bonded_tokens" yaml:"bonded_tokens"` +} + +func (m *Pool) Reset() { *m = Pool{} } +func (m *Pool) String() string { return proto.CompactTextString(m) } +func (*Pool) ProtoMessage() {} +func (*Pool) Descriptor() ([]byte, []int) { + return fileDescriptor_146003fcdb99b683, []int{23} +} +func (m *Pool) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Pool) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Pool.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 *Pool) XXX_Merge(src proto.Message) { + xxx_messageInfo_Pool.Merge(m, src) +} +func (m *Pool) XXX_Size() int { + return m.Size() +} +func (m *Pool) XXX_DiscardUnknown() { + xxx_messageInfo_Pool.DiscardUnknown(m) +} + +var xxx_messageInfo_Pool proto.InternalMessageInfo + func init() { proto.RegisterType((*MsgCreateValidator)(nil), "cosmos.staking.MsgCreateValidator") proto.RegisterType((*MsgEditValidator)(nil), "cosmos.staking.MsgEditValidator") @@ -1237,118 +1436,728 @@ func init() { proto.RegisterType((*RedelegationEntry)(nil), "cosmos.staking.RedelegationEntry") proto.RegisterType((*Redelegation)(nil), "cosmos.staking.Redelegation") proto.RegisterType((*Params)(nil), "cosmos.staking.Params") + proto.RegisterType((*DelegationResponse)(nil), "cosmos.staking.DelegationResponse") + proto.RegisterType((*RedelegationEntryResponse)(nil), "cosmos.staking.RedelegationEntryResponse") + proto.RegisterType((*RedelegationResponse)(nil), "cosmos.staking.RedelegationResponse") + proto.RegisterType((*Pool)(nil), "cosmos.staking.Pool") } func init() { proto.RegisterFile("cosmos/staking/staking.proto", fileDescriptor_146003fcdb99b683) } var fileDescriptor_146003fcdb99b683 = []byte{ - // 1657 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x59, 0xcd, 0x6f, 0x1b, 0xc7, - 0x15, 0xd7, 0x92, 0x14, 0x25, 0x3d, 0x4a, 0xa4, 0xb4, 0xaa, 0x65, 0x4a, 0xb6, 0xb9, 0xf2, 0x1e, - 0x0a, 0xa1, 0xa8, 0x29, 0xd4, 0x2d, 0x60, 0x40, 0x6d, 0x81, 0x8a, 0xa4, 0x04, 0x09, 0xb5, 0x00, - 0x77, 0x65, 0xeb, 0xd0, 0x16, 0x20, 0x86, 0xbb, 0xa3, 0xd5, 0x56, 0xdc, 0x5d, 0x76, 0x67, 0x68, - 0x4b, 0x45, 0xaf, 0x05, 0x8a, 0xa2, 0x45, 0x7d, 0xf4, 0xd1, 0xc8, 0x1f, 0x90, 0x1c, 0x93, 0xfc, - 0x07, 0xce, 0xcd, 0xc8, 0x21, 0x08, 0x72, 0x60, 0x12, 0xfb, 0x90, 0x9c, 0x79, 0xc8, 0x21, 0xa7, - 0x60, 0x3e, 0xf6, 0x43, 0x4b, 0x2a, 0xa2, 0x14, 0xc7, 0x31, 0x60, 0x5d, 0x6c, 0xce, 0xdb, 0xdf, - 0x7b, 0x6f, 0xe6, 0x7d, 0xcf, 0x08, 0xae, 0x9b, 0x3e, 0x71, 0x7d, 0xb2, 0x4a, 0x28, 0x3a, 0x74, - 0x3c, 0x3b, 0xfc, 0xbf, 0xda, 0x09, 0x7c, 0xea, 0xab, 0x45, 0xf1, 0xb5, 0x2a, 0xa9, 0x4b, 0x3f, - 0xb3, 0x7d, 0xdb, 0xe7, 0x9f, 0x56, 0xd9, 0x2f, 0x81, 0x5a, 0xba, 0x49, 0xb1, 0x67, 0xe1, 0xc0, - 0x75, 0x3c, 0xba, 0x8a, 0x5a, 0xa6, 0xb3, 0x4a, 0x8f, 0x3b, 0x98, 0x88, 0x7f, 0x25, 0x44, 0xb3, - 0x7d, 0xdf, 0x6e, 0xe3, 0x55, 0xbe, 0x6a, 0x75, 0xf7, 0x57, 0xa9, 0xe3, 0x62, 0x42, 0x91, 0xdb, - 0x91, 0x80, 0x4a, 0x1a, 0x60, 0x75, 0x03, 0x44, 0x1d, 0xdf, 0x93, 0xdf, 0xe7, 0xe5, 0x3e, 0xe5, - 0x86, 0x38, 0x51, 0xef, 0xe5, 0x40, 0xdd, 0x21, 0x76, 0x3d, 0xc0, 0x88, 0xe2, 0x3d, 0xd4, 0x76, - 0x2c, 0x44, 0xfd, 0x40, 0xad, 0x43, 0xc1, 0xc2, 0xc4, 0x0c, 0x9c, 0x0e, 0x13, 0x50, 0x56, 0x96, - 0x95, 0x95, 0xc2, 0xed, 0x6b, 0xd5, 0x93, 0x67, 0xa9, 0x36, 0x62, 0x48, 0x2d, 0xf7, 0xac, 0xa7, - 0x8d, 0x19, 0x49, 0x2e, 0x75, 0x03, 0xc0, 0xf4, 0x5d, 0xd7, 0x21, 0x84, 0xc9, 0xc8, 0x70, 0x19, - 0x5a, 0x5a, 0x46, 0x3d, 0x42, 0x18, 0x88, 0x62, 0x22, 0xe5, 0x24, 0x18, 0xd5, 0x7f, 0xc2, 0xbc, - 0xeb, 0x78, 0x4d, 0x82, 0xdb, 0xfb, 0x4d, 0x0b, 0xb7, 0xb1, 0xcd, 0x0f, 0x55, 0xce, 0x2e, 0x2b, - 0x2b, 0x53, 0xb5, 0xbb, 0x0c, 0xfe, 0x59, 0x4f, 0xfb, 0xb9, 0xed, 0xd0, 0x83, 0x6e, 0xab, 0x6a, - 0xfa, 0xee, 0xea, 0x89, 0x73, 0xde, 0x22, 0xd6, 0xa1, 0xb4, 0xe3, 0xb6, 0x47, 0xfb, 0x3d, 0x6d, - 0xe9, 0x18, 0xb9, 0xed, 0x35, 0x7d, 0x88, 0x48, 0xdd, 0x98, 0x73, 0x1d, 0x6f, 0x17, 0xb7, 0xf7, - 0x1b, 0x11, 0x4d, 0xfd, 0x07, 0xcc, 0x49, 0x84, 0x1f, 0x34, 0x91, 0x65, 0x05, 0x98, 0x90, 0x72, - 0x6e, 0x59, 0x59, 0x99, 0xae, 0xed, 0xf4, 0x7b, 0x5a, 0x59, 0x48, 0x1b, 0x80, 0xe8, 0xdf, 0xf6, - 0xb4, 0x5b, 0x23, 0xec, 0x69, 0xdd, 0x34, 0xd7, 0x05, 0x87, 0x31, 0x1b, 0x09, 0x91, 0x14, 0xa6, - 0xfb, 0x61, 0xe8, 0x92, 0x48, 0xf7, 0x78, 0x5a, 0xf7, 0x00, 0x64, 0x54, 0xdd, 0x7b, 0xa8, 0x1d, - 0xe9, 0x8e, 0x84, 0x84, 0xba, 0x17, 0x20, 0xdf, 0xe9, 0xb6, 0x0e, 0xf1, 0x71, 0x39, 0xcf, 0x0c, - 0x6d, 0xc8, 0x95, 0xba, 0x02, 0xe3, 0x0f, 0x51, 0xbb, 0x8b, 0xcb, 0x13, 0xdc, 0x9f, 0xd3, 0xa1, - 0x3f, 0xeb, 0xbe, 0x13, 0x06, 0x81, 0x00, 0xac, 0xe5, 0xbe, 0x7e, 0xaa, 0x29, 0xfa, 0x07, 0x59, - 0x98, 0xdd, 0x21, 0xf6, 0x86, 0xe5, 0xd0, 0x57, 0x1c, 0x5e, 0x9d, 0x61, 0xd6, 0xc9, 0x70, 0xeb, - 0xd4, 0xfb, 0x3d, 0xad, 0x28, 0xac, 0xf3, 0x2a, 0x6d, 0xe2, 0x42, 0x29, 0x8e, 0xcb, 0x66, 0x80, - 0x28, 0x96, 0x51, 0xd8, 0x18, 0x31, 0x02, 0x1b, 0xd8, 0xec, 0xf7, 0xb4, 0x05, 0xb1, 0xb3, 0x94, - 0x28, 0xdd, 0x28, 0x9a, 0x27, 0x72, 0x41, 0x3d, 0x1a, 0x1e, 0xf8, 0x39, 0xae, 0x72, 0xeb, 0x47, - 0x0c, 0x7a, 0xe9, 0xba, 0xf7, 0x33, 0x50, 0xd8, 0x21, 0xb6, 0xa4, 0xe3, 0xe1, 0xa9, 0xa0, 0xfc, - 0x84, 0xa9, 0x90, 0x79, 0x3d, 0xa9, 0xf0, 0x0b, 0xc8, 0x23, 0xd7, 0xef, 0x7a, 0x94, 0x7b, 0x7b, - 0x78, 0xcc, 0x4b, 0x84, 0xb4, 0xdc, 0xc7, 0x59, 0x5e, 0x55, 0x6b, 0xd8, 0x76, 0x3c, 0x03, 0x5b, - 0x6f, 0x82, 0x01, 0xff, 0xa5, 0xc0, 0x95, 0xd8, 0x3c, 0x24, 0x30, 0x53, 0x56, 0xfc, 0x53, 0xbf, - 0xa7, 0x5d, 0x4f, 0x5b, 0x31, 0x01, 0xbb, 0x80, 0x25, 0xe7, 0x23, 0x41, 0xbb, 0x81, 0x39, 0x7c, - 0x1f, 0x16, 0xa1, 0xd1, 0x3e, 0xb2, 0xa7, 0xef, 0x23, 0x01, 0xfb, 0x41, 0xfb, 0x68, 0x10, 0x3a, - 0xe8, 0xd4, 0xdc, 0x88, 0x4e, 0xfd, 0x30, 0x03, 0x33, 0x3b, 0xc4, 0x7e, 0xe0, 0x59, 0x97, 0x09, - 0x71, 0xde, 0x84, 0xf8, 0xaf, 0x02, 0xc5, 0x2d, 0x87, 0x50, 0x3f, 0x70, 0x4c, 0xd4, 0xde, 0xf6, - 0xf6, 0x7d, 0xf5, 0xb7, 0x90, 0x3f, 0xc0, 0xc8, 0xc2, 0x81, 0x2c, 0xff, 0x37, 0xaa, 0xf1, 0x0c, - 0x54, 0x65, 0x33, 0x50, 0x55, 0xec, 0x64, 0x8b, 0x83, 0x42, 0xa9, 0x82, 0x45, 0xbd, 0x03, 0xf9, - 0x87, 0xa8, 0x4d, 0x30, 0x2d, 0x67, 0x96, 0xb3, 0x2b, 0x85, 0xdb, 0x8b, 0xe9, 0xde, 0x11, 0xf5, - 0x9a, 0x90, 0x51, 0xc0, 0xe5, 0x76, 0xde, 0xcb, 0x40, 0x29, 0x35, 0x78, 0xa8, 0x35, 0xc8, 0xf1, - 0x8a, 0xae, 0xf0, 0xf2, 0x5a, 0x3d, 0xc7, 0x5c, 0xd1, 0xc0, 0xa6, 0xc1, 0x79, 0xd5, 0xbf, 0xc2, - 0xa4, 0x8b, 0x8e, 0x44, 0x67, 0xc8, 0x70, 0x39, 0xeb, 0xe7, 0x93, 0xd3, 0xef, 0x69, 0x25, 0x59, - 0xaa, 0xa5, 0x1c, 0xdd, 0x98, 0x70, 0xd1, 0x11, 0xef, 0x07, 0x1d, 0x28, 0x31, 0xaa, 0x79, 0x80, - 0x3c, 0x1b, 0x27, 0xdb, 0xcf, 0xd6, 0xb9, 0x95, 0x2c, 0xc4, 0x4a, 0x12, 0xe2, 0x74, 0x63, 0xc6, - 0x45, 0x47, 0x75, 0x4e, 0x60, 0x1a, 0xd7, 0x26, 0x9f, 0x3c, 0xd5, 0xc6, 0xb8, 0xc5, 0x3e, 0x52, - 0x00, 0x62, 0x8b, 0xa9, 0xf7, 0x61, 0x36, 0xd5, 0xbe, 0x88, 0x74, 0xe3, 0x99, 0x03, 0xde, 0x24, - 0xdb, 0xec, 0xf3, 0x9e, 0xa6, 0x18, 0x25, 0x33, 0xe5, 0x82, 0xbf, 0x40, 0xa1, 0xdb, 0xb1, 0x10, - 0xc5, 0x4d, 0x36, 0xdb, 0xca, 0x89, 0x71, 0xa9, 0x2a, 0xe6, 0xda, 0x6a, 0x38, 0xd7, 0x56, 0xef, - 0x87, 0x83, 0x6f, 0xad, 0xc2, 0x64, 0xf5, 0x7b, 0x9a, 0x2a, 0x8e, 0x93, 0x60, 0xd6, 0x1f, 0x7f, - 0xae, 0x29, 0x06, 0x08, 0x0a, 0x63, 0x38, 0x79, 0x96, 0x42, 0x62, 0xb6, 0x50, 0xcb, 0x30, 0xe1, - 0xfa, 0x9e, 0x73, 0x28, 0x43, 0x71, 0xca, 0x08, 0x97, 0xea, 0x12, 0x4c, 0x3a, 0x16, 0xf6, 0xa8, - 0x43, 0x8f, 0x85, 0x3f, 0x8d, 0x68, 0xcd, 0xb8, 0x1e, 0xe1, 0x16, 0x71, 0x42, 0x2f, 0x18, 0xe1, - 0x52, 0xdd, 0x84, 0x59, 0x82, 0xcd, 0x6e, 0xe0, 0xd0, 0xe3, 0xa6, 0xe9, 0x7b, 0x14, 0x99, 0x54, - 0x36, 0xed, 0x6b, 0xfd, 0x9e, 0x76, 0x55, 0xec, 0x35, 0x8d, 0xd0, 0x8d, 0x52, 0x48, 0xaa, 0x0b, - 0x0a, 0xd3, 0x60, 0x61, 0x8a, 0x9c, 0xb6, 0x18, 0xfa, 0xa6, 0x8c, 0x70, 0x99, 0x38, 0xcb, 0xbb, - 0x13, 0x30, 0x15, 0xcf, 0x55, 0x8f, 0x60, 0xd6, 0xef, 0xe0, 0x60, 0x48, 0x3d, 0xba, 0x1b, 0x6b, - 0x4e, 0x23, 0x2e, 0x50, 0x12, 0x4a, 0xa1, 0x8c, 0xb0, 0x22, 0x6c, 0xb2, 0x78, 0xf0, 0x08, 0xf6, - 0x48, 0x97, 0x34, 0xe5, 0xdc, 0x98, 0x49, 0x1f, 0x39, 0x8d, 0xd0, 0x59, 0x04, 0x48, 0xd2, 0x3d, - 0x31, 0x5d, 0x2e, 0x40, 0xfe, 0x6f, 0xc8, 0x69, 0x63, 0x8b, 0xdb, 0x74, 0xd2, 0x90, 0x2b, 0x75, - 0x1b, 0xf2, 0x84, 0x22, 0xda, 0x15, 0xa3, 0xf7, 0x78, 0xed, 0x57, 0x23, 0xee, 0xb9, 0xe6, 0x7b, - 0xd6, 0x2e, 0x67, 0x34, 0xa4, 0x00, 0x75, 0x13, 0xf2, 0xd4, 0x3f, 0xc4, 0x9e, 0x34, 0xea, 0xb9, - 0x32, 0x7d, 0xdb, 0xa3, 0x86, 0xe4, 0x56, 0x29, 0xc4, 0x45, 0xb9, 0x49, 0x0e, 0x50, 0x80, 0x89, - 0x18, 0x95, 0x6b, 0xdb, 0xe7, 0x4e, 0xc7, 0xab, 0xe9, 0x4e, 0x21, 0xe4, 0xe9, 0x46, 0x29, 0x22, - 0xed, 0x72, 0x4a, 0x7a, 0x72, 0x9e, 0xb8, 0xd0, 0xe4, 0xbc, 0x09, 0xb3, 0x5d, 0xaf, 0xe5, 0x7b, - 0x96, 0xe3, 0xd9, 0xcd, 0x03, 0xec, 0xd8, 0x07, 0xb4, 0x3c, 0xb9, 0xac, 0xac, 0x64, 0x93, 0xde, - 0x4a, 0x23, 0x74, 0xa3, 0x14, 0x91, 0xb6, 0x38, 0x45, 0xb5, 0xa0, 0x18, 0xa3, 0x78, 0xca, 0x4e, - 0x9d, 0x99, 0xb2, 0x37, 0x65, 0xca, 0x5e, 0x49, 0x6b, 0x89, 0xb3, 0x76, 0x26, 0x22, 0x32, 0x36, - 0xf5, 0x0f, 0x27, 0xae, 0x91, 0x20, 0x35, 0x9c, 0x5a, 0x65, 0x46, 0xbf, 0x41, 0x16, 0x5e, 0xcb, - 0x0d, 0x72, 0x6d, 0xfa, 0xdf, 0x4f, 0xb5, 0xb1, 0x28, 0x61, 0xff, 0x93, 0x81, 0x7c, 0x63, 0xef, - 0x1e, 0x72, 0x82, 0xb7, 0x75, 0x7c, 0x48, 0x54, 0xaf, 0xdf, 0xc3, 0x84, 0xb0, 0x05, 0x51, 0x6f, - 0xc3, 0x78, 0x87, 0xfd, 0x28, 0x2b, 0xbc, 0xa1, 0x2f, 0x0c, 0x84, 0x34, 0xc7, 0x85, 0x37, 0x4c, - 0x0e, 0xd5, 0xdf, 0xc9, 0x02, 0x34, 0xf6, 0xf6, 0xee, 0x07, 0x4e, 0xa7, 0x8d, 0xe9, 0xe5, 0x78, - 0xfd, 0xe6, 0x8c, 0xd7, 0x09, 0x1f, 0xff, 0x11, 0x0a, 0xb1, 0x8f, 0x88, 0xfa, 0x3b, 0x98, 0xa4, - 0xf2, 0xb7, 0x74, 0xf5, 0xd2, 0xa0, 0xab, 0x43, 0xb8, 0x74, 0x77, 0xc4, 0xa1, 0x7f, 0x92, 0x01, - 0x38, 0xeb, 0x71, 0xe6, 0x2d, 0x18, 0xc0, 0x37, 0x21, 0x2f, 0x3b, 0x4e, 0xf6, 0x42, 0xd3, 0xaa, - 0xe4, 0x4e, 0x78, 0xe9, 0xcb, 0x0c, 0xcc, 0x3f, 0x08, 0xcb, 0xee, 0xa5, 0x85, 0xd5, 0x2d, 0x98, - 0xc0, 0x1e, 0x0d, 0x1c, 0x6e, 0x62, 0x16, 0xa5, 0x2b, 0xe9, 0x28, 0x1d, 0x62, 0xad, 0x0d, 0x8f, - 0x06, 0xc7, 0x32, 0x66, 0x43, 0xf6, 0x84, 0x8d, 0xff, 0x9f, 0x85, 0xf2, 0x69, 0x5c, 0x6a, 0x1d, - 0x4a, 0x66, 0x80, 0x39, 0x21, 0x6c, 0xc9, 0x0a, 0x6f, 0xc9, 0x4b, 0x89, 0x17, 0xa3, 0x93, 0x00, - 0xdd, 0x28, 0x86, 0x14, 0xd9, 0x90, 0x6d, 0xfe, 0x40, 0xc5, 0x52, 0x85, 0xa1, 0x46, 0x1c, 0xa2, - 0x75, 0xd9, 0x91, 0xe3, 0x67, 0xa9, 0xa4, 0x00, 0xd1, 0x92, 0x8b, 0x31, 0x95, 0xf7, 0xe4, 0xbf, - 0x43, 0xc9, 0xf1, 0x1c, 0xea, 0xa0, 0x76, 0xb3, 0x85, 0xda, 0xc8, 0x33, 0x2f, 0x72, 0x15, 0x11, - 0xdd, 0x54, 0xaa, 0x4d, 0x89, 0xd3, 0x8d, 0xa2, 0xa4, 0xd4, 0x04, 0x81, 0x79, 0x24, 0x54, 0x95, - 0xbb, 0xd0, 0xe0, 0x16, 0xb2, 0x27, 0x3c, 0xf2, 0xbf, 0x2c, 0xcc, 0x45, 0xef, 0x33, 0x97, 0xae, - 0x18, 0xd5, 0x15, 0x3b, 0x00, 0xa2, 0x80, 0xb0, 0xce, 0x71, 0x01, 0x6f, 0xb0, 0x12, 0x34, 0x25, - 0x24, 0x34, 0x08, 0x4d, 0xf8, 0xe3, 0xab, 0x2c, 0x4c, 0x27, 0xfd, 0x71, 0xd9, 0xd2, 0xdf, 0xa0, - 0x17, 0xb3, 0xf5, 0xb8, 0x24, 0xe6, 0x78, 0x49, 0xbc, 0x99, 0x2e, 0x89, 0x03, 0xa9, 0x74, 0x7a, - 0x2d, 0xfc, 0x26, 0x03, 0xf9, 0x7b, 0x28, 0x40, 0x2e, 0x51, 0xcd, 0x81, 0x5b, 0x84, 0x78, 0x49, - 0x58, 0x1c, 0x48, 0x94, 0x86, 0xfc, 0x83, 0xd6, 0x19, 0x97, 0x88, 0x27, 0x43, 0x2f, 0x11, 0x45, - 0x17, 0x1d, 0x35, 0xa3, 0x73, 0x09, 0x27, 0xce, 0xd4, 0x16, 0x63, 0x29, 0x27, 0xbf, 0x8b, 0xb7, - 0x90, 0xe8, 0x6a, 0x4d, 0xd4, 0x3b, 0x50, 0x60, 0x88, 0xb8, 0x2b, 0x30, 0xf6, 0x85, 0xf8, 0xf1, - 0x21, 0xf1, 0x51, 0x37, 0xc0, 0x45, 0x47, 0x1b, 0x62, 0xa1, 0xde, 0x05, 0xf5, 0x20, 0x7a, 0xfa, - 0x6a, 0xc6, 0x26, 0x64, 0xfc, 0x37, 0xfa, 0x3d, 0x6d, 0x51, 0xf0, 0x0f, 0x62, 0x74, 0x63, 0x2e, - 0x26, 0x86, 0xd2, 0x7e, 0x03, 0xc0, 0xce, 0xd5, 0xb4, 0xb0, 0xe7, 0xbb, 0xf2, 0x0a, 0x7b, 0xa5, - 0xdf, 0xd3, 0xe6, 0x84, 0x94, 0xf8, 0x9b, 0x6e, 0x4c, 0xb1, 0x45, 0x83, 0xfd, 0x8e, 0x0d, 0x5f, - 0xdb, 0x7c, 0xf6, 0xa2, 0xa2, 0x3c, 0x7f, 0x51, 0x51, 0xbe, 0x78, 0x51, 0x51, 0x1e, 0xbf, 0xac, - 0x8c, 0x3d, 0x7f, 0x59, 0x19, 0xfb, 0xf4, 0x65, 0x65, 0xec, 0xcf, 0xbf, 0xfc, 0xde, 0x18, 0x39, - 0x8a, 0xfe, 0xbe, 0xc9, 0xa3, 0xa5, 0x95, 0xe7, 0x5e, 0xf9, 0xf5, 0x77, 0x01, 0x00, 0x00, 0xff, - 0xff, 0x28, 0x97, 0x39, 0x40, 0xfe, 0x1c, 0x00, 0x00, + // 1836 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x19, 0xcd, 0x6f, 0x1b, 0x59, + 0x3d, 0x63, 0xbb, 0x4e, 0xf2, 0x73, 0x62, 0x27, 0xaf, 0x6d, 0xd6, 0xc9, 0x76, 0x33, 0xe9, 0x1c, + 0x50, 0x40, 0xbb, 0x8e, 0x28, 0x48, 0x2b, 0x05, 0x90, 0xa8, 0xed, 0x46, 0x89, 0x68, 0xa4, 0x32, + 0xed, 0x06, 0x09, 0x90, 0xac, 0xe7, 0x99, 0x57, 0x67, 0xc8, 0x7c, 0x98, 0x79, 0xcf, 0xdd, 0x04, + 0xed, 0x15, 0x09, 0x21, 0x3e, 0xf6, 0xb8, 0xc7, 0x8a, 0x3f, 0x00, 0x8e, 0xc0, 0x99, 0xcb, 0x72, + 0xab, 0x38, 0x20, 0xc4, 0x61, 0x80, 0xf6, 0x00, 0xe2, 0x84, 0x7c, 0xe0, 0xc0, 0x05, 0xf4, 0x3e, + 0xe6, 0xc3, 0x63, 0x67, 0x63, 0x87, 0xb2, 0x54, 0x6a, 0x2e, 0xad, 0xdf, 0x6f, 0x7e, 0x5f, 0xef, + 0xf7, 0xfd, 0x7e, 0x81, 0x5b, 0x56, 0x40, 0xbd, 0x80, 0xee, 0x50, 0x86, 0x4f, 0x1c, 0xbf, 0x17, + 0xff, 0xdf, 0xe8, 0x87, 0x01, 0x0b, 0x50, 0x55, 0x7e, 0x6d, 0x28, 0xe8, 0xc6, 0x8d, 0x5e, 0xd0, + 0x0b, 0xc4, 0xa7, 0x1d, 0xfe, 0x4b, 0x62, 0x6d, 0xdc, 0x66, 0xc4, 0xb7, 0x49, 0xe8, 0x39, 0x3e, + 0xdb, 0xc1, 0x5d, 0xcb, 0xd9, 0x61, 0x67, 0x7d, 0x42, 0xe5, 0xbf, 0x0a, 0x45, 0xef, 0x05, 0x41, + 0xcf, 0x25, 0x3b, 0xe2, 0xd4, 0x1d, 0x3c, 0xde, 0x61, 0x8e, 0x47, 0x28, 0xc3, 0x5e, 0x5f, 0x21, + 0x6c, 0xe6, 0x11, 0xec, 0x41, 0x88, 0x99, 0x13, 0xf8, 0xea, 0xfb, 0x75, 0xa5, 0xa7, 0x52, 0x48, + 0x00, 0x8d, 0xa8, 0x04, 0xe8, 0x90, 0xf6, 0x5a, 0x21, 0xc1, 0x8c, 0x1c, 0x61, 0xd7, 0xb1, 0x31, + 0x0b, 0x42, 0xd4, 0x82, 0x8a, 0x4d, 0xa8, 0x15, 0x3a, 0x7d, 0xce, 0xa0, 0xae, 0x6d, 0x69, 0xdb, + 0x95, 0x3b, 0x6f, 0x36, 0x46, 0xef, 0xd2, 0x68, 0xa7, 0x28, 0xcd, 0xd2, 0xc7, 0x91, 0x3e, 0x67, + 0x66, 0xa9, 0xd0, 0x3d, 0x00, 0x2b, 0xf0, 0x3c, 0x87, 0x52, 0xce, 0xa3, 0x20, 0x78, 0xe8, 0x79, + 0x1e, 0xad, 0x04, 0xc3, 0xc4, 0x8c, 0x50, 0xc5, 0x27, 0x43, 0x88, 0x3e, 0x80, 0xeb, 0x9e, 0xe3, + 0x77, 0x28, 0x71, 0x1f, 0x77, 0x6c, 0xe2, 0x92, 0x9e, 0xb8, 0x54, 0xbd, 0xb8, 0xa5, 0x6d, 0x2f, + 0x36, 0xef, 0x73, 0xf4, 0x3f, 0x46, 0xfa, 0x67, 0x7a, 0x0e, 0x3b, 0x1e, 0x74, 0x1b, 0x56, 0xe0, + 0xed, 0x8c, 0xdc, 0xf3, 0x1d, 0x6a, 0x9f, 0x28, 0x3b, 0x1e, 0xf8, 0x6c, 0x18, 0xe9, 0x1b, 0x67, + 0xd8, 0x73, 0x77, 0x8d, 0x09, 0x2c, 0x0d, 0x73, 0xd5, 0x73, 0xfc, 0x87, 0xc4, 0x7d, 0xdc, 0x4e, + 0x60, 0xe8, 0x7b, 0xb0, 0xaa, 0x30, 0x82, 0xb0, 0x83, 0x6d, 0x3b, 0x24, 0x94, 0xd6, 0x4b, 0x5b, + 0xda, 0xf6, 0x52, 0xf3, 0x70, 0x18, 0xe9, 0x75, 0xc9, 0x6d, 0x0c, 0xc5, 0xf8, 0x57, 0xa4, 0xbf, + 0x33, 0x85, 0x4e, 0x77, 0x2d, 0xeb, 0xae, 0xa4, 0x30, 0x57, 0x12, 0x26, 0x0a, 0xc2, 0x65, 0x3f, + 0x89, 0x5d, 0x92, 0xc8, 0xbe, 0x96, 0x97, 0x3d, 0x86, 0x32, 0xad, 0xec, 0x23, 0xec, 0x26, 0xb2, + 0x13, 0x26, 0xb1, 0xec, 0x35, 0x28, 0xf7, 0x07, 0xdd, 0x13, 0x72, 0x56, 0x2f, 0x73, 0x43, 0x9b, + 0xea, 0x84, 0xb6, 0xe1, 0xda, 0x13, 0xec, 0x0e, 0x48, 0x7d, 0x5e, 0xf8, 0x73, 0x29, 0xf6, 0x67, + 0x2b, 0x70, 0xe2, 0x20, 0x90, 0x08, 0xbb, 0xa5, 0xbf, 0x3d, 0xd5, 0x35, 0xe3, 0x57, 0x45, 0x58, + 0x39, 0xa4, 0xbd, 0x7b, 0xb6, 0xc3, 0x5e, 0x72, 0x78, 0xf5, 0x27, 0x59, 0xa7, 0x20, 0xac, 0xd3, + 0x1a, 0x46, 0x7a, 0x55, 0x5a, 0xe7, 0x65, 0xda, 0xc4, 0x83, 0x5a, 0x1a, 0x97, 0x9d, 0x10, 0x33, + 0xa2, 0xa2, 0xb0, 0x3d, 0x65, 0x04, 0xb6, 0x89, 0x35, 0x8c, 0xf4, 0x35, 0xa9, 0x59, 0x8e, 0x95, + 0x61, 0x56, 0xad, 0x91, 0x5c, 0x40, 0xa7, 0x93, 0x03, 0xbf, 0x24, 0x44, 0xee, 0xff, 0x0f, 0x83, + 0x5e, 0xb9, 0xee, 0x97, 0x05, 0xa8, 0x1c, 0xd2, 0x9e, 0x82, 0x93, 0xc9, 0xa9, 0xa0, 0xfd, 0x1f, + 0x53, 0xa1, 0xf0, 0xe9, 0xa4, 0xc2, 0xe7, 0xa0, 0x8c, 0xbd, 0x60, 0xe0, 0x33, 0xe1, 0xed, 0xc9, + 0x31, 0xaf, 0x30, 0x94, 0xe5, 0x7e, 0x57, 0x14, 0x55, 0xb5, 0x49, 0x7a, 0x8e, 0x6f, 0x12, 0xfb, + 0x55, 0x30, 0xe0, 0xf7, 0x35, 0xb8, 0x99, 0x9a, 0x87, 0x86, 0x56, 0xce, 0x8a, 0x5f, 0x1f, 0x46, + 0xfa, 0xad, 0xbc, 0x15, 0x33, 0x68, 0x97, 0xb0, 0xe4, 0xf5, 0x84, 0xd1, 0xc3, 0xd0, 0x9a, 0xac, + 0x87, 0x4d, 0x59, 0xa2, 0x47, 0xf1, 0x7c, 0x3d, 0x32, 0x68, 0xff, 0x95, 0x1e, 0x6d, 0xca, 0xc6, + 0x9d, 0x5a, 0x9a, 0xd2, 0xa9, 0xbf, 0x2e, 0xc0, 0xf2, 0x21, 0xed, 0xbd, 0xe7, 0xdb, 0x57, 0x09, + 0x31, 0x6b, 0x42, 0xfc, 0x48, 0x83, 0xea, 0xbe, 0x43, 0x59, 0x10, 0x3a, 0x16, 0x76, 0x0f, 0xfc, + 0xc7, 0x01, 0xfa, 0x12, 0x94, 0x8f, 0x09, 0xb6, 0x49, 0xa8, 0xca, 0xff, 0x5b, 0x8d, 0x74, 0x06, + 0x6a, 0xf0, 0x19, 0xa8, 0x21, 0x35, 0xd9, 0x17, 0x48, 0x31, 0x57, 0x49, 0x82, 0xde, 0x85, 0xf2, + 0x13, 0xec, 0x52, 0xc2, 0xea, 0x85, 0xad, 0xe2, 0x76, 0xe5, 0xce, 0x7a, 0xbe, 0x77, 0x24, 0xbd, + 0x26, 0x26, 0x94, 0xe8, 0x4a, 0x9d, 0x5f, 0x14, 0xa0, 0x96, 0x1b, 0x3c, 0x50, 0x13, 0x4a, 0xa2, + 0xa2, 0x6b, 0xa2, 0xbc, 0x36, 0x66, 0x98, 0x2b, 0xda, 0xc4, 0x32, 0x05, 0x2d, 0xfa, 0x36, 0x2c, + 0x78, 0xf8, 0x54, 0x76, 0x86, 0x82, 0xe0, 0x73, 0x77, 0x36, 0x3e, 0xc3, 0x48, 0xaf, 0xa9, 0x52, + 0xad, 0xf8, 0x18, 0xe6, 0xbc, 0x87, 0x4f, 0x45, 0x3f, 0xe8, 0x43, 0x8d, 0x43, 0xad, 0x63, 0xec, + 0xf7, 0x48, 0xb6, 0xfd, 0xec, 0xcf, 0x2c, 0x64, 0x2d, 0x15, 0x92, 0x61, 0x67, 0x98, 0xcb, 0x1e, + 0x3e, 0x6d, 0x09, 0x00, 0x97, 0xb8, 0xbb, 0xf0, 0xd1, 0x53, 0x7d, 0x4e, 0x58, 0xec, 0xb7, 0x1a, + 0x40, 0x6a, 0x31, 0xf4, 0x08, 0x56, 0x72, 0xed, 0x8b, 0x2a, 0x37, 0x5e, 0x38, 0xe0, 0x2d, 0x70, + 0x65, 0x9f, 0x45, 0xba, 0x66, 0xd6, 0xac, 0x9c, 0x0b, 0xbe, 0x05, 0x95, 0x41, 0xdf, 0xc6, 0x8c, + 0x74, 0xf8, 0x6c, 0xab, 0x26, 0xc6, 0x8d, 0x86, 0x9c, 0x6b, 0x1b, 0xf1, 0x5c, 0xdb, 0x78, 0x14, + 0x0f, 0xbe, 0xcd, 0x4d, 0xce, 0x6b, 0x18, 0xe9, 0x48, 0x5e, 0x27, 0x43, 0x6c, 0x7c, 0xf8, 0x27, + 0x5d, 0x33, 0x41, 0x42, 0x38, 0xc1, 0xe8, 0x5d, 0x2a, 0x99, 0xd9, 0x02, 0xd5, 0x61, 0xde, 0x0b, + 0x7c, 0xe7, 0x44, 0x85, 0xe2, 0xa2, 0x19, 0x1f, 0xd1, 0x06, 0x2c, 0x38, 0x36, 0xf1, 0x99, 0xc3, + 0xce, 0xa4, 0x3f, 0xcd, 0xe4, 0xcc, 0xa9, 0xde, 0x27, 0x5d, 0xea, 0xc4, 0x5e, 0x30, 0xe3, 0x23, + 0xda, 0x83, 0x15, 0x4a, 0xac, 0x41, 0xe8, 0xb0, 0xb3, 0x8e, 0x15, 0xf8, 0x0c, 0x5b, 0x4c, 0x35, + 0xed, 0x37, 0x87, 0x91, 0xfe, 0x86, 0xd4, 0x35, 0x8f, 0x61, 0x98, 0xb5, 0x18, 0xd4, 0x92, 0x10, + 0x2e, 0xc1, 0x26, 0x0c, 0x3b, 0xae, 0x1c, 0xfa, 0x16, 0xcd, 0xf8, 0x98, 0xb9, 0xcb, 0xcf, 0xe7, + 0x61, 0x31, 0x9d, 0xab, 0xde, 0x87, 0x95, 0xa0, 0x4f, 0xc2, 0x09, 0xf5, 0xe8, 0x7e, 0x2a, 0x39, + 0x8f, 0x71, 0x89, 0x92, 0x50, 0x8b, 0x79, 0xc4, 0x15, 0x61, 0x8f, 0xc7, 0x83, 0x4f, 0x89, 0x4f, + 0x07, 0xb4, 0xa3, 0xe6, 0xc6, 0x42, 0xfe, 0xca, 0x79, 0x0c, 0x83, 0x47, 0x80, 0x02, 0x3d, 0x90, + 0xd3, 0xe5, 0x1a, 0x94, 0xbf, 0x83, 0x1d, 0x97, 0xd8, 0xc2, 0xa6, 0x0b, 0xa6, 0x3a, 0xa1, 0x03, + 0x28, 0x53, 0x86, 0xd9, 0x40, 0x8e, 0xde, 0xd7, 0x9a, 0x9f, 0x9f, 0x52, 0xe7, 0x66, 0xe0, 0xdb, + 0x0f, 0x05, 0xa1, 0xa9, 0x18, 0xa0, 0x3d, 0x28, 0xb3, 0xe0, 0x84, 0xf8, 0xca, 0xa8, 0x33, 0x65, + 0xfa, 0x81, 0xcf, 0x4c, 0x45, 0x8d, 0x18, 0xa4, 0x45, 0xb9, 0x43, 0x8f, 0x71, 0x48, 0xa8, 0x1c, + 0x95, 0x9b, 0x07, 0x33, 0xa7, 0xe3, 0x1b, 0xf9, 0x4e, 0x21, 0xf9, 0x19, 0x66, 0x2d, 0x01, 0x3d, + 0x14, 0x90, 0xfc, 0xe4, 0x3c, 0x7f, 0xa9, 0xc9, 0x79, 0x0f, 0x56, 0x06, 0x7e, 0x37, 0xf0, 0x6d, + 0xc7, 0xef, 0x75, 0x8e, 0x89, 0xd3, 0x3b, 0x66, 0xf5, 0x85, 0x2d, 0x6d, 0xbb, 0x98, 0xf5, 0x56, + 0x1e, 0xc3, 0x30, 0x6b, 0x09, 0x68, 0x5f, 0x40, 0x90, 0x0d, 0xd5, 0x14, 0x4b, 0xa4, 0xec, 0xe2, + 0x85, 0x29, 0x7b, 0x5b, 0xa5, 0xec, 0xcd, 0xbc, 0x94, 0x34, 0x6b, 0x97, 0x13, 0x20, 0x27, 0x43, + 0x5f, 0x1d, 0x79, 0x46, 0x82, 0x92, 0x70, 0x6e, 0x95, 0x99, 0xfe, 0x05, 0x59, 0xf9, 0x54, 0x5e, + 0x90, 0xbb, 0x4b, 0x3f, 0x78, 0xaa, 0xcf, 0x25, 0x09, 0xfb, 0xc3, 0x02, 0x94, 0xdb, 0x47, 0x0f, + 0xb0, 0x13, 0xbe, 0xae, 0xe3, 0x43, 0xa6, 0x7a, 0x7d, 0x05, 0xe6, 0xa5, 0x2d, 0x28, 0xba, 0x03, + 0xd7, 0xfa, 0xfc, 0x47, 0x5d, 0x13, 0x0d, 0x7d, 0x6d, 0x2c, 0xa4, 0x05, 0x5e, 0xfc, 0xc2, 0x14, + 0xa8, 0xc6, 0xcf, 0x8a, 0x00, 0xed, 0xa3, 0xa3, 0x47, 0xa1, 0xd3, 0x77, 0x09, 0xbb, 0x1a, 0xaf, + 0x5f, 0x9d, 0xf1, 0x3a, 0xe3, 0xe3, 0xaf, 0x41, 0x25, 0xf5, 0x11, 0x45, 0x5f, 0x86, 0x05, 0xa6, + 0x7e, 0x2b, 0x57, 0x6f, 0x8c, 0xbb, 0x3a, 0x46, 0x57, 0xee, 0x4e, 0x28, 0x8c, 0xdf, 0x17, 0x00, + 0x2e, 0x5a, 0xce, 0xbc, 0x06, 0x03, 0xf8, 0x1e, 0x94, 0x55, 0xc7, 0x29, 0x5e, 0x6a, 0x5a, 0x55, + 0xd4, 0x19, 0x2f, 0xfd, 0xa5, 0x00, 0xd7, 0xdf, 0x8b, 0xcb, 0xee, 0x95, 0x85, 0xd1, 0x3e, 0xcc, + 0x13, 0x9f, 0x85, 0x8e, 0x30, 0x31, 0x8f, 0xd2, 0xed, 0x7c, 0x94, 0x4e, 0xb0, 0xd6, 0x3d, 0x9f, + 0x85, 0x67, 0x2a, 0x66, 0x63, 0xf2, 0x8c, 0x8d, 0x7f, 0x5a, 0x84, 0xfa, 0x79, 0x54, 0xa8, 0x05, + 0x35, 0x2b, 0x24, 0x02, 0x10, 0xb7, 0x64, 0x4d, 0xb4, 0xe4, 0x8d, 0xcc, 0xc6, 0x68, 0x14, 0xc1, + 0x30, 0xab, 0x31, 0x44, 0x35, 0xe4, 0x9e, 0x58, 0x50, 0xf1, 0x54, 0xe1, 0x58, 0x53, 0x0e, 0xd1, + 0x86, 0xea, 0xc8, 0xe9, 0x5a, 0x2a, 0xcb, 0x40, 0xb6, 0xe4, 0x6a, 0x0a, 0x15, 0x3d, 0xf9, 0xbb, + 0x50, 0x73, 0x7c, 0x87, 0x39, 0xd8, 0xed, 0x74, 0xb1, 0x8b, 0x7d, 0xeb, 0x32, 0x4f, 0x11, 0xd9, + 0x4d, 0x95, 0xd8, 0x1c, 0x3b, 0xc3, 0xac, 0x2a, 0x48, 0x53, 0x02, 0xb8, 0x47, 0x62, 0x51, 0xa5, + 0x4b, 0x0d, 0x6e, 0x31, 0x79, 0xc6, 0x23, 0x3f, 0x2e, 0xc2, 0x6a, 0xb2, 0x9f, 0xb9, 0x72, 0xc5, + 0xb4, 0xae, 0x38, 0x04, 0x90, 0x05, 0x84, 0x77, 0x8e, 0x4b, 0x78, 0x83, 0x97, 0xa0, 0x45, 0xc9, + 0xa1, 0x4d, 0x59, 0xc6, 0x1f, 0x7f, 0x2d, 0xc2, 0x52, 0xd6, 0x1f, 0x57, 0x2d, 0xfd, 0x15, 0xda, + 0x98, 0xdd, 0x4d, 0x4b, 0x62, 0x49, 0x94, 0xc4, 0xdb, 0xf9, 0x92, 0x38, 0x96, 0x4a, 0xe7, 0xd7, + 0xc2, 0x7f, 0x16, 0xa0, 0xfc, 0x00, 0x87, 0xd8, 0xa3, 0xc8, 0x1a, 0x7b, 0x45, 0xc8, 0x4d, 0xc2, + 0xfa, 0x58, 0xa2, 0xb4, 0xd5, 0x1f, 0xb4, 0x2e, 0x78, 0x44, 0x7c, 0x34, 0xf1, 0x11, 0x51, 0xf5, + 0xf0, 0x69, 0x27, 0xb9, 0x97, 0x74, 0xe2, 0x72, 0x73, 0x3d, 0xe5, 0x32, 0xfa, 0x5d, 0xee, 0x42, + 0x92, 0xa7, 0x35, 0x45, 0xef, 0x42, 0x85, 0x63, 0xa4, 0x5d, 0x81, 0x93, 0xaf, 0xa5, 0xcb, 0x87, + 0xcc, 0x47, 0xc3, 0x04, 0x0f, 0x9f, 0xde, 0x93, 0x07, 0x74, 0x1f, 0xd0, 0x71, 0xb2, 0xfa, 0xea, + 0xa4, 0x26, 0xe4, 0xf4, 0x6f, 0x0d, 0x23, 0x7d, 0x5d, 0xd2, 0x8f, 0xe3, 0x18, 0xe6, 0x6a, 0x0a, + 0x8c, 0xb9, 0x7d, 0x11, 0x80, 0xdf, 0xab, 0x63, 0x13, 0x3f, 0xf0, 0xd4, 0x13, 0xf6, 0xe6, 0x30, + 0xd2, 0x57, 0x25, 0x97, 0xf4, 0x9b, 0x61, 0x2e, 0xf2, 0x43, 0x9b, 0xff, 0xce, 0x18, 0xfe, 0x27, + 0x1a, 0xa0, 0xb4, 0xf7, 0x98, 0x84, 0xf6, 0xf9, 0x13, 0x9c, 0x3f, 0xb2, 0x32, 0x2f, 0x23, 0x6d, + 0xf2, 0x23, 0x2b, 0xa5, 0x8b, 0x1f, 0x59, 0x99, 0x54, 0x7d, 0x3b, 0xad, 0xcf, 0x85, 0x73, 0xb7, + 0x82, 0x13, 0x6a, 0xf0, 0x6f, 0x34, 0x58, 0x1f, 0x0b, 0x9c, 0x44, 0xaf, 0x23, 0x40, 0x61, 0xe6, + 0xa3, 0x30, 0xcd, 0x99, 0xd2, 0x6f, 0xea, 0xf8, 0x5b, 0x0d, 0xc7, 0x6a, 0xfc, 0xcb, 0xeb, 0x26, + 0x6a, 0xa3, 0xa8, 0xc1, 0x8d, 0xac, 0xf8, 0xe4, 0x02, 0x7b, 0xb0, 0x94, 0x95, 0xae, 0x54, 0xbf, + 0xf5, 0x49, 0xaa, 0x2b, 0xad, 0x47, 0xe8, 0xd0, 0x41, 0x9a, 0x7d, 0x72, 0xe5, 0xf9, 0xd9, 0x0b, + 0x6f, 0x1f, 0xeb, 0x90, 0xcf, 0x42, 0xa9, 0xf1, 0xbf, 0x35, 0x28, 0x3d, 0x08, 0x02, 0x17, 0x05, + 0xb0, 0xea, 0x07, 0xac, 0xc3, 0x83, 0x85, 0xd8, 0x1d, 0xb5, 0x1b, 0x91, 0x5b, 0xd0, 0xd6, 0x6c, + 0x46, 0xf9, 0x7b, 0xa4, 0x8f, 0xb3, 0x32, 0x6b, 0x7e, 0xc0, 0x9a, 0x02, 0xf2, 0x48, 0x6e, 0x4e, + 0x3e, 0x80, 0xe5, 0x51, 0x61, 0x72, 0x53, 0xf4, 0x8d, 0x99, 0x85, 0x8d, 0xb2, 0x19, 0x46, 0xfa, + 0x8d, 0x34, 0x09, 0x12, 0xb0, 0x61, 0x2e, 0x75, 0x33, 0xd2, 0x77, 0x17, 0xf8, 0xed, 0xff, 0xf1, + 0x54, 0xd7, 0x9a, 0x7b, 0x1f, 0x3f, 0xdf, 0xd4, 0x9e, 0x3d, 0xdf, 0xd4, 0xfe, 0xfc, 0x7c, 0x53, + 0xfb, 0xf0, 0xc5, 0xe6, 0xdc, 0xb3, 0x17, 0x9b, 0x73, 0x7f, 0x78, 0xb1, 0x39, 0xf7, 0xcd, 0xb7, + 0x3f, 0x51, 0x85, 0xd3, 0xe4, 0x4f, 0xfd, 0x42, 0x99, 0x6e, 0x59, 0x14, 0xa8, 0x2f, 0xfc, 0x27, + 0x00, 0x00, 0xff, 0xff, 0xb2, 0x69, 0x31, 0x7c, 0x09, 0x20, 0x00, 0x00, +} + +func (this *Pool) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) { + return StakingDescription() +} +func StakingDescription() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) { + d := &github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet{} + var gzipped = []byte{ + // 9157 bytes of a gzipped FileDescriptorSet + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x7d, 0x7d, 0x70, 0x24, 0xc7, + 0x75, 0x1f, 0xf6, 0x03, 0xfb, 0xf1, 0x16, 0x58, 0x2c, 0x1a, 0x38, 0x1c, 0x6e, 0x49, 0x62, 0xef, + 0xe6, 0xc8, 0x3b, 0xdc, 0x91, 0xc4, 0x51, 0xa7, 0x23, 0x29, 0xee, 0x49, 0xa4, 0xb0, 0x00, 0xee, + 0x0e, 0x24, 0x70, 0x07, 0x0e, 0x80, 0x23, 0x45, 0x59, 0x9e, 0x0c, 0x66, 0x1b, 0x8b, 0xe1, 0xed, + 0xce, 0x2c, 0x67, 0x66, 0xef, 0x00, 0x96, 0x52, 0xc5, 0x94, 0xfc, 0x21, 0x39, 0xb2, 0x25, 0x3b, + 0x76, 0x42, 0xcb, 0x92, 0x4c, 0x2b, 0x95, 0x48, 0x56, 0x62, 0xf9, 0x23, 0x8e, 0x2c, 0x39, 0xff, + 0xa8, 0x2a, 0xe5, 0x58, 0xa9, 0x72, 0xa5, 0xa4, 0x94, 0x93, 0x72, 0xa5, 0x52, 0xb0, 0x45, 0xa9, + 0xca, 0x8e, 0xc2, 0x24, 0xce, 0x85, 0x71, 0xb9, 0xa4, 0x3f, 0x92, 0xea, 0xaf, 0xf9, 0xda, 0x59, + 0xcc, 0xe0, 0x74, 0xa4, 0xe8, 0x92, 0xfe, 0xc2, 0x76, 0xcf, 0x7b, 0xbf, 0xee, 0x7e, 0xfd, 0xfa, + 0xbd, 0xd7, 0xaf, 0x7b, 0x06, 0xf0, 0x6b, 0x17, 0xe1, 0x78, 0xcb, 0x34, 0x5b, 0x6d, 0x7c, 0xae, + 0x6b, 0x99, 0x8e, 0xb9, 0xd5, 0xdb, 0x3e, 0xd7, 0xc4, 0xb6, 0x66, 0xe9, 0x5d, 0xc7, 0xb4, 0xe6, + 0x68, 0x1d, 0x1a, 0x63, 0x14, 0x73, 0x82, 0x42, 0x5a, 0x85, 0xf1, 0x4b, 0x7a, 0x1b, 0x2f, 0xba, + 0x84, 0xeb, 0xd8, 0x41, 0xef, 0x81, 0xec, 0xb6, 0xde, 0xc6, 0xd3, 0xa9, 0xe3, 0x99, 0xd9, 0xd2, + 0xf9, 0xfb, 0xe7, 0x42, 0x4c, 0x73, 0x41, 0x8e, 0x35, 0x52, 0x2d, 0x53, 0x0e, 0xe9, 0x3b, 0x59, + 0x98, 0x88, 0x78, 0x8a, 0x10, 0x64, 0x0d, 0xb5, 0x43, 0x10, 0x53, 0xb3, 0x45, 0x99, 0xfe, 0x46, + 0xd3, 0x90, 0xef, 0xaa, 0xda, 0x0d, 0xb5, 0x85, 0xa7, 0xd3, 0xb4, 0x5a, 0x14, 0xd1, 0x0c, 0x40, + 0x13, 0x77, 0xb1, 0xd1, 0xc4, 0x86, 0xb6, 0x37, 0x9d, 0x39, 0x9e, 0x99, 0x2d, 0xca, 0xbe, 0x1a, + 0xf4, 0x20, 0x8c, 0x77, 0x7b, 0x5b, 0x6d, 0x5d, 0x53, 0x7c, 0x64, 0x70, 0x3c, 0x33, 0x3b, 0x2c, + 0x57, 0xd8, 0x83, 0x45, 0x8f, 0xf8, 0x34, 0x8c, 0xdd, 0xc2, 0xea, 0x0d, 0x3f, 0x69, 0x89, 0x92, + 0x96, 0x49, 0xb5, 0x8f, 0x70, 0x01, 0x46, 0x3a, 0xd8, 0xb6, 0xd5, 0x16, 0x56, 0x9c, 0xbd, 0x2e, + 0x9e, 0xce, 0xd2, 0xd1, 0x1f, 0xef, 0x1b, 0x7d, 0x78, 0xe4, 0x25, 0xce, 0xb5, 0xb1, 0xd7, 0xc5, + 0x68, 0x1e, 0x8a, 0xd8, 0xe8, 0x75, 0x18, 0xc2, 0xf0, 0x00, 0xf9, 0x2d, 0x19, 0xbd, 0x4e, 0x18, + 0xa5, 0x40, 0xd8, 0x38, 0x44, 0xde, 0xc6, 0xd6, 0x4d, 0x5d, 0xc3, 0xd3, 0x39, 0x0a, 0x70, 0xba, + 0x0f, 0x60, 0x9d, 0x3d, 0x0f, 0x63, 0x08, 0x3e, 0xb4, 0x00, 0x45, 0xbc, 0xeb, 0x60, 0xc3, 0xd6, + 0x4d, 0x63, 0x3a, 0x4f, 0x41, 0x1e, 0x88, 0x98, 0x45, 0xdc, 0x6e, 0x86, 0x21, 0x3c, 0x3e, 0xf4, + 0x18, 0xe4, 0xcd, 0xae, 0xa3, 0x9b, 0x86, 0x3d, 0x5d, 0x38, 0x9e, 0x9a, 0x2d, 0x9d, 0xbf, 0x37, + 0x52, 0x11, 0xae, 0x31, 0x1a, 0x59, 0x10, 0xa3, 0x65, 0xa8, 0xd8, 0x66, 0xcf, 0xd2, 0xb0, 0xa2, + 0x99, 0x4d, 0xac, 0xe8, 0xc6, 0xb6, 0x39, 0x5d, 0xa4, 0x00, 0xb5, 0xfe, 0x81, 0x50, 0xc2, 0x05, + 0xb3, 0x89, 0x97, 0x8d, 0x6d, 0x53, 0x2e, 0xdb, 0x81, 0x32, 0x9a, 0x82, 0x9c, 0xbd, 0x67, 0x38, + 0xea, 0xee, 0xf4, 0x08, 0xd5, 0x10, 0x5e, 0x92, 0xbe, 0x9a, 0x83, 0xb1, 0x24, 0x2a, 0x76, 0x11, + 0x86, 0xb7, 0xc9, 0x28, 0xa7, 0xd3, 0x87, 0x91, 0x01, 0xe3, 0x09, 0x0a, 0x31, 0x77, 0x87, 0x42, + 0x9c, 0x87, 0x92, 0x81, 0x6d, 0x07, 0x37, 0x99, 0x46, 0x64, 0x12, 0xea, 0x14, 0x30, 0xa6, 0x7e, + 0x95, 0xca, 0xde, 0x91, 0x4a, 0x3d, 0x0f, 0x63, 0x6e, 0x97, 0x14, 0x4b, 0x35, 0x5a, 0x42, 0x37, + 0xcf, 0xc5, 0xf5, 0x64, 0x6e, 0x49, 0xf0, 0xc9, 0x84, 0x4d, 0x2e, 0xe3, 0x40, 0x19, 0x2d, 0x02, + 0x98, 0x06, 0x36, 0xb7, 0x95, 0x26, 0xd6, 0xda, 0xd3, 0x85, 0x01, 0x52, 0xba, 0x46, 0x48, 0xfa, + 0xa4, 0x64, 0xb2, 0x5a, 0xad, 0x8d, 0x9e, 0xf0, 0x54, 0x2d, 0x3f, 0x40, 0x53, 0x56, 0xd9, 0x22, + 0xeb, 0xd3, 0xb6, 0x4d, 0x28, 0x5b, 0x98, 0xe8, 0x3d, 0x6e, 0xf2, 0x91, 0x15, 0x69, 0x27, 0xe6, + 0x62, 0x47, 0x26, 0x73, 0x36, 0x36, 0xb0, 0x51, 0xcb, 0x5f, 0x44, 0x27, 0xc1, 0xad, 0x50, 0xa8, + 0x5a, 0x01, 0xb5, 0x42, 0x23, 0xa2, 0xf2, 0xaa, 0xda, 0xc1, 0xd5, 0x97, 0xa1, 0x1c, 0x14, 0x0f, + 0x9a, 0x84, 0x61, 0xdb, 0x51, 0x2d, 0x87, 0x6a, 0xe1, 0xb0, 0xcc, 0x0a, 0xa8, 0x02, 0x19, 0x6c, + 0x34, 0xa9, 0x95, 0x1b, 0x96, 0xc9, 0x4f, 0xf4, 0x7e, 0x6f, 0xc0, 0x19, 0x3a, 0xe0, 0x53, 0xfd, + 0x33, 0x1a, 0x40, 0x0e, 0x8f, 0xbb, 0xfa, 0x38, 0x8c, 0x06, 0x06, 0x90, 0xb4, 0x69, 0xe9, 0xc3, + 0x70, 0x24, 0x12, 0x1a, 0x3d, 0x0f, 0x93, 0x3d, 0x43, 0x37, 0x1c, 0x6c, 0x75, 0x2d, 0x4c, 0x34, + 0x96, 0x35, 0x35, 0xfd, 0x97, 0xf9, 0x01, 0x3a, 0xb7, 0xe9, 0xa7, 0x66, 0x28, 0xf2, 0x44, 0xaf, + 0xbf, 0xf2, 0x6c, 0xb1, 0xf0, 0x57, 0xf9, 0xca, 0x2b, 0xaf, 0xbc, 0xf2, 0x4a, 0x5a, 0x7a, 0x35, + 0x07, 0x93, 0x51, 0x6b, 0x26, 0x72, 0xf9, 0x4e, 0x41, 0xce, 0xe8, 0x75, 0xb6, 0xb0, 0x45, 0x85, + 0x34, 0x2c, 0xf3, 0x12, 0x9a, 0x87, 0xe1, 0xb6, 0xba, 0x85, 0xdb, 0xd3, 0xd9, 0xe3, 0xa9, 0xd9, + 0xf2, 0xf9, 0x07, 0x13, 0xad, 0xca, 0xb9, 0x15, 0xc2, 0x22, 0x33, 0x4e, 0xf4, 0x24, 0x64, 0xb9, + 0x89, 0x26, 0x08, 0x67, 0x93, 0x21, 0x90, 0xb5, 0x24, 0x53, 0x3e, 0x74, 0x0f, 0x14, 0xc9, 0x5f, + 0xa6, 0x1b, 0x39, 0xda, 0xe7, 0x02, 0xa9, 0x20, 0x7a, 0x81, 0xaa, 0x50, 0xa0, 0xcb, 0xa4, 0x89, + 0x85, 0x6b, 0x73, 0xcb, 0x44, 0xb1, 0x9a, 0x78, 0x5b, 0xed, 0xb5, 0x1d, 0xe5, 0xa6, 0xda, 0xee, + 0x61, 0xaa, 0xf0, 0x45, 0x79, 0x84, 0x57, 0x5e, 0x27, 0x75, 0xa8, 0x06, 0x25, 0xb6, 0xaa, 0x74, + 0xa3, 0x89, 0x77, 0xa9, 0xf5, 0x1c, 0x96, 0xd9, 0x42, 0x5b, 0x26, 0x35, 0xa4, 0xf9, 0x17, 0x6d, + 0xd3, 0x10, 0xaa, 0x49, 0x9b, 0x20, 0x15, 0xb4, 0xf9, 0xc7, 0xc3, 0x86, 0xfb, 0xbe, 0xe8, 0xe1, + 0x85, 0x75, 0x4a, 0xfa, 0x72, 0x1a, 0xb2, 0xd4, 0x5e, 0x8c, 0x41, 0x69, 0xe3, 0x03, 0x6b, 0x4b, + 0xca, 0xe2, 0xb5, 0xcd, 0xc6, 0xca, 0x52, 0x25, 0x85, 0xca, 0x00, 0xb4, 0xe2, 0xd2, 0xca, 0xb5, + 0xf9, 0x8d, 0x4a, 0xda, 0x2d, 0x2f, 0x5f, 0xdd, 0x78, 0xec, 0x42, 0x25, 0xe3, 0x32, 0x6c, 0xb2, + 0x8a, 0xac, 0x9f, 0xe0, 0xdd, 0xe7, 0x2b, 0xc3, 0xa8, 0x02, 0x23, 0x0c, 0x60, 0xf9, 0xf9, 0xa5, + 0xc5, 0xc7, 0x2e, 0x54, 0x72, 0xc1, 0x9a, 0x77, 0x9f, 0xaf, 0xe4, 0xd1, 0x28, 0x14, 0x69, 0x4d, + 0xe3, 0xda, 0xb5, 0x95, 0x4a, 0xc1, 0xc5, 0x5c, 0xdf, 0x90, 0x97, 0xaf, 0x5e, 0xae, 0x14, 0x5d, + 0xcc, 0xcb, 0xf2, 0xb5, 0xcd, 0xb5, 0x0a, 0xb8, 0x08, 0xab, 0x4b, 0xeb, 0xeb, 0xf3, 0x97, 0x97, + 0x2a, 0x25, 0x97, 0xa2, 0xf1, 0x81, 0x8d, 0xa5, 0xf5, 0xca, 0x48, 0xa0, 0x5b, 0xef, 0x3e, 0x5f, + 0x19, 0x75, 0x9b, 0x58, 0xba, 0xba, 0xb9, 0x5a, 0x29, 0xa3, 0x71, 0x18, 0x65, 0x4d, 0x88, 0x4e, + 0x8c, 0x85, 0xaa, 0x1e, 0xbb, 0x50, 0xa9, 0x78, 0x1d, 0x61, 0x28, 0xe3, 0x81, 0x8a, 0xc7, 0x2e, + 0x54, 0x90, 0xb4, 0x00, 0xc3, 0x54, 0xbb, 0x10, 0x82, 0xf2, 0xca, 0x7c, 0x63, 0x69, 0x45, 0xb9, + 0xb6, 0xb6, 0xb1, 0x7c, 0xed, 0xea, 0xfc, 0x4a, 0x25, 0xe5, 0xd5, 0xc9, 0x4b, 0xcf, 0x6e, 0x2e, + 0xcb, 0x4b, 0x8b, 0x95, 0xb4, 0xbf, 0x6e, 0x6d, 0x69, 0x7e, 0x63, 0x69, 0xb1, 0x92, 0x91, 0x34, + 0x98, 0x8c, 0xb2, 0x93, 0x91, 0x2b, 0xc3, 0x37, 0xc5, 0xe9, 0x01, 0x53, 0x4c, 0xb1, 0xfa, 0xa6, + 0xf8, 0xdb, 0x69, 0x98, 0x88, 0xf0, 0x15, 0x91, 0x8d, 0x3c, 0x05, 0xc3, 0x4c, 0x45, 0x99, 0xf7, + 0x3c, 0x13, 0xe9, 0x74, 0xa8, 0xc2, 0xf6, 0x79, 0x50, 0xca, 0xe7, 0x8f, 0x20, 0x32, 0x03, 0x22, + 0x08, 0x02, 0xd1, 0x67, 0xd3, 0x3f, 0xd4, 0x67, 0xd3, 0x99, 0xdb, 0x7b, 0x2c, 0x89, 0xdb, 0xa3, + 0x75, 0x87, 0xb3, 0xed, 0xc3, 0x11, 0xb6, 0xfd, 0x22, 0x8c, 0xf7, 0x01, 0x25, 0xb6, 0xb1, 0x1f, + 0x49, 0xc1, 0xf4, 0x20, 0xe1, 0xc4, 0x58, 0xba, 0x74, 0xc0, 0xd2, 0x5d, 0x0c, 0x4b, 0xf0, 0xc4, + 0xe0, 0x49, 0xe8, 0x9b, 0xeb, 0xcf, 0xa7, 0x60, 0x2a, 0x3a, 0x52, 0x8c, 0xec, 0xc3, 0x93, 0x90, + 0xeb, 0x60, 0x67, 0xc7, 0x14, 0xd1, 0xd2, 0xa9, 0x08, 0x1f, 0x4c, 0x1e, 0x87, 0x27, 0x9b, 0x73, + 0xf9, 0x9d, 0x78, 0x66, 0x50, 0xb8, 0xc7, 0x7a, 0xd3, 0xd7, 0xd3, 0x8f, 0xa5, 0xe1, 0x48, 0x24, + 0x78, 0x64, 0x47, 0xef, 0x03, 0xd0, 0x8d, 0x6e, 0xcf, 0x61, 0x11, 0x11, 0x33, 0xb0, 0x45, 0x5a, + 0x43, 0x8d, 0x17, 0x31, 0x9e, 0x3d, 0xc7, 0x7d, 0x9e, 0xa1, 0xcf, 0x81, 0x55, 0x51, 0x82, 0xf7, + 0x78, 0x1d, 0xcd, 0xd2, 0x8e, 0xce, 0x0c, 0x18, 0x69, 0x9f, 0x62, 0x3e, 0x02, 0x15, 0xad, 0xad, + 0x63, 0xc3, 0x51, 0x6c, 0xc7, 0xc2, 0x6a, 0x47, 0x37, 0x5a, 0xd4, 0x83, 0x14, 0xea, 0xc3, 0xdb, + 0x6a, 0xdb, 0xc6, 0xf2, 0x18, 0x7b, 0xbc, 0x2e, 0x9e, 0x12, 0x0e, 0xaa, 0x40, 0x96, 0x8f, 0x23, + 0x17, 0xe0, 0x60, 0x8f, 0x5d, 0x0e, 0xe9, 0x97, 0x8a, 0x50, 0xf2, 0xc5, 0xd5, 0xe8, 0x04, 0x8c, + 0xbc, 0xa8, 0xde, 0x54, 0x15, 0xb1, 0x57, 0x62, 0x92, 0x28, 0x91, 0xba, 0x35, 0xbe, 0x5f, 0x7a, + 0x04, 0x26, 0x29, 0x89, 0xd9, 0x73, 0xb0, 0xa5, 0x68, 0x6d, 0xd5, 0xb6, 0xa9, 0xd0, 0x0a, 0x94, + 0x14, 0x91, 0x67, 0xd7, 0xc8, 0xa3, 0x05, 0xf1, 0x04, 0x3d, 0x0a, 0x13, 0x94, 0xa3, 0xd3, 0x6b, + 0x3b, 0x7a, 0xb7, 0x8d, 0x15, 0xb2, 0x7b, 0xb3, 0xa9, 0x27, 0x71, 0x7b, 0x36, 0x4e, 0x28, 0x56, + 0x39, 0x01, 0xe9, 0x91, 0x8d, 0x16, 0xe1, 0x3e, 0xca, 0xd6, 0xc2, 0x06, 0xb6, 0x54, 0x07, 0x2b, + 0xf8, 0xa5, 0x9e, 0xda, 0xb6, 0x15, 0xd5, 0x68, 0x2a, 0x3b, 0xaa, 0xbd, 0x33, 0x3d, 0x49, 0x00, + 0x1a, 0xe9, 0xe9, 0x94, 0x7c, 0x8c, 0x10, 0x5e, 0xe6, 0x74, 0x4b, 0x94, 0x6c, 0xde, 0x68, 0x5e, + 0x51, 0xed, 0x1d, 0x54, 0x87, 0x29, 0x8a, 0x62, 0x3b, 0x96, 0x6e, 0xb4, 0x14, 0x6d, 0x07, 0x6b, + 0x37, 0x94, 0x9e, 0xb3, 0xfd, 0x9e, 0xe9, 0x7b, 0xfc, 0xed, 0xd3, 0x1e, 0xae, 0x53, 0x9a, 0x05, + 0x42, 0xb2, 0xe9, 0x6c, 0xbf, 0x07, 0xad, 0xc3, 0x08, 0x99, 0x8c, 0x8e, 0xfe, 0x32, 0x56, 0xb6, + 0x4d, 0x8b, 0xba, 0xc6, 0x72, 0x84, 0x69, 0xf2, 0x49, 0x70, 0xee, 0x1a, 0x67, 0x58, 0x35, 0x9b, + 0xb8, 0x3e, 0xbc, 0xbe, 0xb6, 0xb4, 0xb4, 0x28, 0x97, 0x04, 0xca, 0x25, 0xd3, 0x22, 0x0a, 0xd5, + 0x32, 0x5d, 0x01, 0x97, 0x98, 0x42, 0xb5, 0x4c, 0x21, 0xde, 0x47, 0x61, 0x42, 0xd3, 0xd8, 0x98, + 0x75, 0x4d, 0xe1, 0x7b, 0x2c, 0x7b, 0xba, 0x12, 0x10, 0x96, 0xa6, 0x5d, 0x66, 0x04, 0x5c, 0xc7, + 0x6d, 0xf4, 0x04, 0x1c, 0xf1, 0x84, 0xe5, 0x67, 0x1c, 0xef, 0x1b, 0x65, 0x98, 0xf5, 0x51, 0x98, + 0xe8, 0xee, 0xf5, 0x33, 0xa2, 0x40, 0x8b, 0xdd, 0xbd, 0x30, 0xdb, 0xe3, 0x30, 0xd9, 0xdd, 0xe9, + 0xf6, 0xf3, 0x9d, 0xf5, 0xf3, 0xa1, 0xee, 0x4e, 0x37, 0xcc, 0xf8, 0x00, 0xdd, 0x70, 0x5b, 0x58, + 0x53, 0x1d, 0xdc, 0x9c, 0x3e, 0xea, 0x27, 0xf7, 0x3d, 0x40, 0xe7, 0xa0, 0xa2, 0x69, 0x0a, 0x36, + 0xd4, 0xad, 0x36, 0x56, 0x54, 0x0b, 0x1b, 0xaa, 0x3d, 0x5d, 0xf3, 0x13, 0x97, 0x35, 0x6d, 0x89, + 0x3e, 0x9d, 0xa7, 0x0f, 0xd1, 0x59, 0x18, 0x37, 0xb7, 0x5e, 0xd4, 0x98, 0x4a, 0x2a, 0x5d, 0x0b, + 0x6f, 0xeb, 0xbb, 0xd3, 0xf7, 0x53, 0xf9, 0x8e, 0x91, 0x07, 0x54, 0x21, 0xd7, 0x68, 0x35, 0x3a, + 0x03, 0x15, 0xcd, 0xde, 0x51, 0xad, 0x2e, 0xb5, 0xc9, 0x76, 0x57, 0xd5, 0xf0, 0xf4, 0x03, 0x8c, + 0x94, 0xd5, 0x5f, 0x15, 0xd5, 0x64, 0x49, 0xd8, 0xb7, 0xf4, 0x6d, 0x47, 0x20, 0x9e, 0x66, 0x4b, + 0x82, 0xd6, 0x71, 0xb4, 0x59, 0xa8, 0x10, 0x51, 0x04, 0x1a, 0x9e, 0xa5, 0x64, 0xe5, 0xee, 0x4e, + 0xd7, 0xdf, 0xee, 0x49, 0x18, 0x25, 0x94, 0x5e, 0xa3, 0x67, 0x58, 0x40, 0xd6, 0xdd, 0xf1, 0xb5, + 0x78, 0x01, 0xa6, 0x08, 0x51, 0x07, 0x3b, 0x6a, 0x53, 0x75, 0x54, 0x1f, 0xf5, 0x43, 0x94, 0x9a, + 0xc8, 0x7d, 0x95, 0x3f, 0x0c, 0xf4, 0xd3, 0xea, 0x6d, 0xed, 0xb9, 0x9a, 0xf5, 0x30, 0xeb, 0x27, + 0xa9, 0x13, 0xba, 0xf5, 0x96, 0x05, 0xdd, 0x52, 0x1d, 0x46, 0xfc, 0x8a, 0x8f, 0x8a, 0xc0, 0x54, + 0xbf, 0x92, 0x22, 0x51, 0xd0, 0xc2, 0xb5, 0x45, 0x12, 0xbf, 0xbc, 0xb0, 0x54, 0x49, 0x93, 0x38, + 0x6a, 0x65, 0x79, 0x63, 0x49, 0x91, 0x37, 0xaf, 0x6e, 0x2c, 0xaf, 0x2e, 0x55, 0x32, 0xbe, 0x80, + 0xfd, 0xe9, 0x6c, 0xe1, 0x54, 0xe5, 0xb4, 0xf4, 0xcd, 0x34, 0x94, 0x83, 0x3b, 0x30, 0xf4, 0x5e, + 0x38, 0x2a, 0xd2, 0x25, 0x36, 0x76, 0x94, 0x5b, 0xba, 0x45, 0x57, 0x64, 0x47, 0x65, 0xde, 0xd1, + 0xd5, 0x89, 0x49, 0x4e, 0xb5, 0x8e, 0x9d, 0xe7, 0x74, 0x8b, 0xac, 0xb7, 0x8e, 0xea, 0xa0, 0x15, + 0xa8, 0x19, 0xa6, 0x62, 0x3b, 0xaa, 0xd1, 0x54, 0xad, 0xa6, 0xe2, 0x25, 0xaa, 0x14, 0x55, 0xd3, + 0xb0, 0x6d, 0x9b, 0xcc, 0x13, 0xba, 0x28, 0xf7, 0x1a, 0xe6, 0x3a, 0x27, 0xf6, 0x5c, 0xc4, 0x3c, + 0x27, 0x0d, 0xe9, 0x6f, 0x66, 0x90, 0xfe, 0xde, 0x03, 0xc5, 0x8e, 0xda, 0x55, 0xb0, 0xe1, 0x58, + 0x7b, 0x34, 0xee, 0x2e, 0xc8, 0x85, 0x8e, 0xda, 0x5d, 0x22, 0xe5, 0xb7, 0x65, 0xfb, 0xf3, 0x74, + 0xb6, 0x50, 0xa8, 0x14, 0x9f, 0xce, 0x16, 0x8a, 0x15, 0x90, 0x5e, 0xcf, 0xc0, 0x88, 0x3f, 0x0e, + 0x27, 0xdb, 0x1a, 0x8d, 0xba, 0xac, 0x14, 0x35, 0x6a, 0x27, 0x0f, 0x8c, 0xda, 0xe7, 0x16, 0x88, + 0x2f, 0xab, 0xe7, 0x58, 0x74, 0x2c, 0x33, 0x4e, 0x12, 0x47, 0x10, 0x65, 0xc3, 0x2c, 0x1a, 0x29, + 0xc8, 0xbc, 0x84, 0x2e, 0x43, 0xee, 0x45, 0x9b, 0x62, 0xe7, 0x28, 0xf6, 0xfd, 0x07, 0x63, 0x3f, + 0xbd, 0x4e, 0xc1, 0x8b, 0x4f, 0xaf, 0x2b, 0x57, 0xaf, 0xc9, 0xab, 0xf3, 0x2b, 0x32, 0x67, 0x47, + 0xc7, 0x20, 0xdb, 0x56, 0x5f, 0xde, 0x0b, 0x7a, 0x3d, 0x5a, 0x95, 0x74, 0x12, 0x8e, 0x41, 0xf6, + 0x16, 0x56, 0x6f, 0x04, 0x7d, 0x0d, 0xad, 0x7a, 0x0b, 0x17, 0xc3, 0x39, 0x18, 0xa6, 0xf2, 0x42, + 0x00, 0x5c, 0x62, 0x95, 0x21, 0x54, 0x80, 0xec, 0xc2, 0x35, 0x99, 0x2c, 0x88, 0x0a, 0x8c, 0xb0, + 0x5a, 0x65, 0x6d, 0x79, 0x69, 0x61, 0xa9, 0x92, 0x96, 0x1e, 0x85, 0x1c, 0x13, 0x02, 0x59, 0x2c, + 0xae, 0x18, 0x2a, 0x43, 0xbc, 0xc8, 0x31, 0x52, 0xe2, 0xe9, 0xe6, 0x6a, 0x63, 0x49, 0xae, 0xa4, + 0x83, 0x53, 0x9d, 0xad, 0x0c, 0x4b, 0x36, 0x8c, 0xf8, 0x03, 0xf1, 0xb7, 0x67, 0x93, 0xfd, 0xb5, + 0x14, 0x94, 0x7c, 0x81, 0x35, 0x89, 0x88, 0xd4, 0x76, 0xdb, 0xbc, 0xa5, 0xa8, 0x6d, 0x5d, 0xb5, + 0xb9, 0x6a, 0x00, 0xad, 0x9a, 0x27, 0x35, 0x49, 0xa7, 0xee, 0x6d, 0x5a, 0x22, 0xc3, 0x95, 0x9c, + 0xf4, 0xd9, 0x14, 0x54, 0xc2, 0x91, 0x6d, 0xa8, 0x9b, 0xa9, 0x1f, 0x66, 0x37, 0xa5, 0x4f, 0xa7, + 0xa0, 0x1c, 0x0c, 0x67, 0x43, 0xdd, 0x3b, 0xf1, 0x43, 0xed, 0xde, 0x5f, 0xa4, 0x61, 0x34, 0x10, + 0xc4, 0x26, 0xed, 0xdd, 0x4b, 0x30, 0xae, 0x37, 0x71, 0xa7, 0x6b, 0x3a, 0xd8, 0xd0, 0xf6, 0x94, + 0x36, 0xbe, 0x89, 0xdb, 0xd3, 0x12, 0x35, 0x1a, 0xe7, 0x0e, 0x0e, 0x93, 0xe7, 0x96, 0x3d, 0xbe, + 0x15, 0xc2, 0x56, 0x9f, 0x58, 0x5e, 0x5c, 0x5a, 0x5d, 0xbb, 0xb6, 0xb1, 0x74, 0x75, 0xe1, 0x03, + 0xca, 0xe6, 0xd5, 0x67, 0xae, 0x5e, 0x7b, 0xee, 0xaa, 0x5c, 0xd1, 0x43, 0x64, 0x6f, 0xe1, 0xb2, + 0x5f, 0x83, 0x4a, 0xb8, 0x53, 0xe8, 0x28, 0x44, 0x75, 0xab, 0x32, 0x84, 0x26, 0x60, 0xec, 0xea, + 0x35, 0x65, 0x7d, 0x79, 0x71, 0x49, 0x59, 0xba, 0x74, 0x69, 0x69, 0x61, 0x63, 0x9d, 0x25, 0x3e, + 0x5c, 0xea, 0x8d, 0xc0, 0x02, 0x97, 0x3e, 0x95, 0x81, 0x89, 0x88, 0x9e, 0xa0, 0x79, 0xbe, 0x65, + 0x61, 0xbb, 0xa8, 0x87, 0x93, 0xf4, 0x7e, 0x8e, 0xc4, 0x0c, 0x6b, 0xaa, 0xe5, 0xf0, 0x1d, 0xce, + 0x19, 0x20, 0x52, 0x32, 0x1c, 0x7d, 0x5b, 0xc7, 0x16, 0xcf, 0x13, 0xb1, 0x7d, 0xcc, 0x98, 0x57, + 0xcf, 0x52, 0x45, 0x0f, 0x01, 0xea, 0x9a, 0xb6, 0xee, 0xe8, 0x37, 0xb1, 0xa2, 0x1b, 0x22, 0xa9, + 0x44, 0xf6, 0x35, 0x59, 0xb9, 0x22, 0x9e, 0x2c, 0x1b, 0x8e, 0x4b, 0x6d, 0xe0, 0x96, 0x1a, 0xa2, + 0x26, 0xc6, 0x3c, 0x23, 0x57, 0xc4, 0x13, 0x97, 0xfa, 0x04, 0x8c, 0x34, 0xcd, 0x1e, 0x09, 0xf6, + 0x18, 0x1d, 0xf1, 0x1d, 0x29, 0xb9, 0xc4, 0xea, 0x5c, 0x12, 0x1e, 0xc6, 0x7b, 0xd9, 0xac, 0x11, + 0xb9, 0xc4, 0xea, 0x18, 0xc9, 0x69, 0x18, 0x53, 0x5b, 0x2d, 0x8b, 0x80, 0x0b, 0x20, 0xb6, 0x31, + 0x29, 0xbb, 0xd5, 0x94, 0xb0, 0xfa, 0x34, 0x14, 0x84, 0x1c, 0x88, 0xab, 0x26, 0x92, 0x50, 0xba, + 0x6c, 0xb7, 0x9d, 0x9e, 0x2d, 0xca, 0x05, 0x43, 0x3c, 0x3c, 0x01, 0x23, 0xba, 0xad, 0x78, 0xc9, + 0xf9, 0xf4, 0xf1, 0xf4, 0x6c, 0x41, 0x2e, 0xe9, 0xb6, 0x9b, 0xd8, 0x94, 0x3e, 0x9f, 0x86, 0x72, + 0xf0, 0x70, 0x01, 0x2d, 0x42, 0xa1, 0x6d, 0x6a, 0x2a, 0x55, 0x2d, 0x76, 0xb2, 0x35, 0x1b, 0x73, + 0x1e, 0x31, 0xb7, 0xc2, 0xe9, 0x65, 0x97, 0xb3, 0xfa, 0x1f, 0x52, 0x50, 0x10, 0xd5, 0x68, 0x0a, + 0xb2, 0x5d, 0xd5, 0xd9, 0xa1, 0x70, 0xc3, 0x8d, 0x74, 0x25, 0x25, 0xd3, 0x32, 0xa9, 0xb7, 0xbb, + 0xaa, 0x41, 0x55, 0x80, 0xd7, 0x93, 0x32, 0x99, 0xd7, 0x36, 0x56, 0x9b, 0x74, 0xd7, 0x63, 0x76, + 0x3a, 0xd8, 0x70, 0x6c, 0x31, 0xaf, 0xbc, 0x7e, 0x81, 0x57, 0xa3, 0x07, 0x61, 0xdc, 0xb1, 0x54, + 0xbd, 0x1d, 0xa0, 0xcd, 0x52, 0xda, 0x8a, 0x78, 0xe0, 0x12, 0xd7, 0xe1, 0x98, 0xc0, 0x6d, 0x62, + 0x47, 0xd5, 0x76, 0x70, 0xd3, 0x63, 0xca, 0xd1, 0xec, 0xc6, 0x51, 0x4e, 0xb0, 0xc8, 0x9f, 0x0b, + 0x5e, 0xe9, 0x9b, 0x29, 0x18, 0x17, 0xfb, 0xb4, 0xa6, 0x2b, 0xac, 0x55, 0x00, 0xd5, 0x30, 0x4c, + 0xc7, 0x2f, 0xae, 0x7e, 0x55, 0xee, 0xe3, 0x9b, 0x9b, 0x77, 0x99, 0x64, 0x1f, 0x40, 0xb5, 0x03, + 0xe0, 0x3d, 0x19, 0x28, 0xb6, 0x1a, 0x94, 0xf8, 0xc9, 0x11, 0x3d, 0x7e, 0x64, 0x3b, 0x7b, 0x60, + 0x55, 0x64, 0x43, 0x87, 0x26, 0x61, 0x78, 0x0b, 0xb7, 0x74, 0x83, 0xe7, 0x83, 0x59, 0x41, 0xe4, + 0x5f, 0xb2, 0x6e, 0xfe, 0xa5, 0xf1, 0x89, 0x14, 0x4c, 0x68, 0x66, 0x27, 0xdc, 0xdf, 0x46, 0x25, + 0x94, 0x5e, 0xb0, 0xaf, 0xa4, 0x5e, 0x78, 0xb2, 0xa5, 0x3b, 0x3b, 0xbd, 0xad, 0x39, 0xcd, 0xec, + 0x9c, 0x6b, 0x99, 0x6d, 0xd5, 0x68, 0x79, 0xe7, 0xa7, 0xf4, 0x87, 0xf6, 0x70, 0x0b, 0x1b, 0x0f, + 0xb7, 0x4c, 0xdf, 0x69, 0xea, 0x45, 0xef, 0xe7, 0xdf, 0xa6, 0x52, 0x9f, 0x4b, 0x67, 0x2e, 0xaf, + 0x35, 0xbe, 0x98, 0xae, 0x5e, 0x66, 0xcd, 0xad, 0x09, 0xf1, 0xc8, 0x78, 0xbb, 0x8d, 0x35, 0x32, + 0x64, 0xf8, 0xee, 0x83, 0x30, 0xd9, 0x32, 0x5b, 0x26, 0x45, 0x3c, 0x47, 0x7e, 0xf1, 0x13, 0xd9, + 0xa2, 0x5b, 0x5b, 0x8d, 0x3d, 0xbe, 0xad, 0x5f, 0x85, 0x09, 0x4e, 0xac, 0xd0, 0x23, 0x21, 0xb6, + 0xb1, 0x41, 0x07, 0xa6, 0xd5, 0xa6, 0x7f, 0xf7, 0x3b, 0xd4, 0xa1, 0xcb, 0xe3, 0x9c, 0x95, 0x3c, + 0x63, 0x7b, 0x9f, 0xba, 0x0c, 0x47, 0x02, 0x78, 0x6c, 0xd9, 0x62, 0x2b, 0x06, 0xf1, 0x8f, 0x38, + 0xe2, 0x84, 0x0f, 0x71, 0x9d, 0xb3, 0xd6, 0x17, 0x60, 0xf4, 0x30, 0x58, 0xff, 0x8e, 0x63, 0x8d, + 0x60, 0x3f, 0xc8, 0x65, 0x18, 0xa3, 0x20, 0x5a, 0xcf, 0x76, 0xcc, 0x0e, 0xb5, 0x89, 0x07, 0xc3, + 0xfc, 0xf1, 0x77, 0xd8, 0x3a, 0x2a, 0x13, 0xb6, 0x05, 0x97, 0xab, 0x5e, 0x07, 0x7a, 0x0a, 0xd6, + 0xc4, 0x5a, 0x3b, 0x06, 0xe1, 0xeb, 0xbc, 0x23, 0x2e, 0x7d, 0xfd, 0x3a, 0x4c, 0x92, 0xdf, 0xd4, + 0x64, 0xf9, 0x7b, 0x12, 0x9f, 0x83, 0x9b, 0xfe, 0xe6, 0x47, 0xd8, 0x52, 0x9d, 0x70, 0x01, 0x7c, + 0x7d, 0xf2, 0xcd, 0x62, 0x0b, 0x3b, 0x0e, 0xb6, 0x6c, 0x45, 0x6d, 0x47, 0x75, 0xcf, 0x97, 0xc4, + 0x98, 0xfe, 0xd5, 0x37, 0x82, 0xb3, 0x78, 0x99, 0x71, 0xce, 0xb7, 0xdb, 0xf5, 0x4d, 0x38, 0x1a, + 0xa1, 0x15, 0x09, 0x30, 0x3f, 0xc5, 0x31, 0x27, 0xfb, 0x34, 0x83, 0xc0, 0xae, 0x81, 0xa8, 0x77, + 0xe7, 0x32, 0x01, 0xe6, 0xaf, 0x71, 0x4c, 0xc4, 0x79, 0xc5, 0x94, 0x12, 0xc4, 0xa7, 0x61, 0xfc, + 0x26, 0xb6, 0xb6, 0x4c, 0x9b, 0x27, 0x8e, 0x12, 0xc0, 0x7d, 0x9a, 0xc3, 0x8d, 0x71, 0x46, 0x9a, + 0x49, 0x22, 0x58, 0x4f, 0x40, 0x61, 0x5b, 0xd5, 0x70, 0x02, 0x88, 0xcf, 0x70, 0x88, 0x3c, 0xa1, + 0x27, 0xac, 0xf3, 0x30, 0xd2, 0x32, 0xb9, 0xd7, 0x8a, 0x67, 0xff, 0x2c, 0x67, 0x2f, 0x09, 0x1e, + 0x0e, 0xd1, 0x35, 0xbb, 0xbd, 0x36, 0x71, 0x69, 0xf1, 0x10, 0xbf, 0x2e, 0x20, 0x04, 0x0f, 0x87, + 0x38, 0x84, 0x58, 0x5f, 0x13, 0x10, 0xb6, 0x4f, 0x9e, 0x4f, 0x41, 0xc9, 0x34, 0xda, 0x7b, 0xa6, + 0x91, 0xa4, 0x13, 0xbf, 0xc1, 0x11, 0x80, 0xb3, 0x10, 0x80, 0x8b, 0x50, 0x4c, 0x3a, 0x11, 0xff, + 0xec, 0x0d, 0xb1, 0x3c, 0xc4, 0x0c, 0x5c, 0x86, 0x31, 0x61, 0xa0, 0x74, 0xd3, 0x48, 0x00, 0xf1, + 0xcf, 0x39, 0x44, 0xd9, 0xc7, 0xc6, 0x87, 0xe1, 0x60, 0xdb, 0x69, 0xe1, 0x24, 0x20, 0x9f, 0x17, + 0xc3, 0xe0, 0x2c, 0x5c, 0x94, 0x5b, 0xd8, 0xd0, 0x76, 0x92, 0x21, 0x7c, 0x41, 0x88, 0x52, 0xf0, + 0x10, 0x88, 0x05, 0x18, 0xed, 0xa8, 0x96, 0xbd, 0xa3, 0xb6, 0x13, 0x4d, 0xc7, 0x6f, 0x72, 0x8c, + 0x11, 0x97, 0x89, 0x4b, 0xa4, 0x67, 0x1c, 0x06, 0xe6, 0x8b, 0x42, 0x22, 0x3e, 0x36, 0xbe, 0xf4, + 0x6c, 0x87, 0x66, 0xd9, 0x0e, 0x83, 0xf6, 0x2f, 0xc4, 0xd2, 0x63, 0xbc, 0xab, 0x7e, 0xc4, 0x8b, + 0x50, 0xb4, 0xf5, 0x97, 0x13, 0xc1, 0xfc, 0x4b, 0x31, 0xd3, 0x94, 0x81, 0x30, 0x7f, 0x00, 0x8e, + 0x45, 0xba, 0x89, 0x04, 0x60, 0xbf, 0xc5, 0xc1, 0xa6, 0x22, 0x5c, 0x05, 0x37, 0x09, 0x87, 0x85, + 0xfc, 0x92, 0x30, 0x09, 0x38, 0x84, 0xb5, 0x46, 0xf6, 0x11, 0xb6, 0xba, 0x7d, 0x38, 0xa9, 0xfd, + 0xb6, 0x90, 0x1a, 0xe3, 0x0d, 0x48, 0x6d, 0x03, 0xa6, 0x38, 0xe2, 0xe1, 0xe6, 0xf5, 0x77, 0x84, + 0x61, 0x65, 0xdc, 0x9b, 0xc1, 0xd9, 0xfd, 0x20, 0x54, 0x5d, 0x71, 0x8a, 0x80, 0xd5, 0x56, 0x3a, + 0x6a, 0x37, 0x01, 0xf2, 0xef, 0x72, 0x64, 0x61, 0xf1, 0xdd, 0x88, 0xd7, 0x5e, 0x55, 0xbb, 0x04, + 0xfc, 0x79, 0x98, 0x16, 0xe0, 0x3d, 0xc3, 0xc2, 0x9a, 0xd9, 0x32, 0xf4, 0x97, 0x71, 0x33, 0x01, + 0xf4, 0xef, 0x85, 0xa6, 0x6a, 0xd3, 0xc7, 0x4e, 0x90, 0x97, 0xa1, 0xe2, 0xc6, 0x2a, 0x8a, 0xde, + 0xe9, 0x9a, 0x96, 0x13, 0x83, 0xf8, 0xaf, 0xc4, 0x4c, 0xb9, 0x7c, 0xcb, 0x94, 0xad, 0xbe, 0x04, + 0x65, 0x5a, 0x4c, 0xaa, 0x92, 0xbf, 0xcf, 0x81, 0x46, 0x3d, 0x2e, 0x6e, 0x38, 0x34, 0xb3, 0xd3, + 0x55, 0xad, 0x24, 0xf6, 0xef, 0x5f, 0x0b, 0xc3, 0xc1, 0x59, 0xb8, 0xe1, 0x70, 0xf6, 0xba, 0x98, + 0x78, 0xfb, 0x04, 0x08, 0x5f, 0x16, 0x86, 0x43, 0xf0, 0x70, 0x08, 0x11, 0x30, 0x24, 0x80, 0xf8, + 0x03, 0x01, 0x21, 0x78, 0x08, 0xc4, 0xb3, 0x9e, 0xa3, 0xb5, 0x70, 0x4b, 0xb7, 0x1d, 0x8b, 0x85, + 0xc9, 0x07, 0x43, 0x7d, 0xe5, 0x8d, 0x60, 0x10, 0x26, 0xfb, 0x58, 0x89, 0x25, 0xe2, 0x69, 0x57, + 0xba, 0x8b, 0x8a, 0xef, 0xd8, 0x57, 0x85, 0x25, 0xf2, 0xb1, 0x91, 0xbe, 0xf9, 0x22, 0x44, 0x22, + 0x76, 0x8d, 0xec, 0x1d, 0x12, 0xc0, 0xfd, 0x61, 0xa8, 0x73, 0xeb, 0x82, 0x97, 0x60, 0xfa, 0xe2, + 0x9f, 0x9e, 0x71, 0x03, 0xef, 0x25, 0xd2, 0xce, 0x7f, 0x13, 0x8a, 0x7f, 0x36, 0x19, 0x27, 0xb3, + 0x21, 0x63, 0xa1, 0x78, 0x0a, 0xc5, 0xdd, 0x1f, 0x9a, 0xfe, 0x07, 0x6f, 0xf2, 0xf1, 0x06, 0xc3, + 0xa9, 0xfa, 0x0a, 0x51, 0xf2, 0x60, 0xd0, 0x13, 0x0f, 0xf6, 0x91, 0x37, 0x5d, 0x3d, 0x0f, 0xc4, + 0x3c, 0xf5, 0x4b, 0x30, 0x1a, 0x08, 0x78, 0xe2, 0xa1, 0x7e, 0x8a, 0x43, 0x8d, 0xf8, 0xe3, 0x9d, + 0xfa, 0xa3, 0x90, 0x25, 0xc1, 0x4b, 0x3c, 0xfb, 0x4f, 0x73, 0x76, 0x4a, 0x5e, 0x7f, 0x1f, 0x14, + 0x44, 0xd0, 0x12, 0xcf, 0xfa, 0x33, 0x9c, 0xd5, 0x65, 0x21, 0xec, 0x22, 0x60, 0x89, 0x67, 0xff, + 0x59, 0xc1, 0x2e, 0x58, 0x08, 0x7b, 0x72, 0x11, 0x7e, 0xed, 0x1f, 0x66, 0xb9, 0xd3, 0x11, 0xb2, + 0xbb, 0x08, 0x79, 0x1e, 0xa9, 0xc4, 0x73, 0x7f, 0x8c, 0x37, 0x2e, 0x38, 0xea, 0x8f, 0xc3, 0x70, + 0x42, 0x81, 0xff, 0x3c, 0x67, 0x65, 0xf4, 0xf5, 0x05, 0x28, 0xf9, 0xa2, 0x93, 0x78, 0xf6, 0x5f, + 0xe0, 0xec, 0x7e, 0x2e, 0xd2, 0x75, 0x1e, 0x9d, 0xc4, 0x03, 0x7c, 0x42, 0x74, 0x9d, 0x73, 0x10, + 0xb1, 0x89, 0xc0, 0x24, 0x9e, 0xfb, 0x93, 0x42, 0xea, 0x82, 0xa5, 0xfe, 0x14, 0x14, 0x5d, 0x67, + 0x13, 0xcf, 0xff, 0x8b, 0x9c, 0xdf, 0xe3, 0x21, 0x12, 0xf0, 0x39, 0xbb, 0x78, 0x88, 0x5f, 0x12, + 0x12, 0xf0, 0x71, 0x91, 0x65, 0x14, 0x0e, 0x60, 0xe2, 0x91, 0xfe, 0x91, 0x58, 0x46, 0xa1, 0xf8, + 0x85, 0xcc, 0x26, 0xb5, 0xf9, 0xf1, 0x10, 0xbf, 0x2c, 0x66, 0x93, 0xd2, 0x93, 0x6e, 0x84, 0x23, + 0x82, 0x78, 0x8c, 0x7f, 0x22, 0xba, 0x11, 0x0a, 0x08, 0xea, 0x6b, 0x80, 0xfa, 0xa3, 0x81, 0x78, + 0xbc, 0x57, 0x39, 0xde, 0x78, 0x5f, 0x30, 0x50, 0x7f, 0x0e, 0xa6, 0xa2, 0x23, 0x81, 0x78, 0xd4, + 0x5f, 0x7d, 0x33, 0xb4, 0x77, 0xf3, 0x07, 0x02, 0xf5, 0x0d, 0xcf, 0xa5, 0xf8, 0xa3, 0x80, 0x78, + 0xd8, 0x4f, 0xbd, 0x19, 0x34, 0xdc, 0xfe, 0x20, 0xa0, 0x3e, 0x0f, 0xe0, 0x39, 0xe0, 0x78, 0xac, + 0x4f, 0x73, 0x2c, 0x1f, 0x13, 0x59, 0x1a, 0xdc, 0xff, 0xc6, 0xf3, 0x7f, 0x46, 0x2c, 0x0d, 0xce, + 0x41, 0x96, 0x86, 0x70, 0xbd, 0xf1, 0xdc, 0x9f, 0x15, 0x4b, 0x43, 0xb0, 0x10, 0xcd, 0xf6, 0x79, + 0xb7, 0x78, 0x84, 0xdf, 0x10, 0x9a, 0xed, 0xe3, 0xaa, 0x5f, 0x85, 0xf1, 0x3e, 0x87, 0x18, 0x0f, + 0xf5, 0x39, 0x0e, 0x55, 0x09, 0xfb, 0x43, 0xbf, 0xf3, 0xe2, 0xce, 0x30, 0x1e, 0xed, 0x9f, 0x86, + 0x9c, 0x17, 0xf7, 0x85, 0xf5, 0x8b, 0x50, 0x30, 0x7a, 0xed, 0x36, 0x59, 0x3c, 0xe8, 0xe0, 0x3b, + 0x7f, 0xd3, 0xff, 0xed, 0xfb, 0x5c, 0x3a, 0x82, 0xa1, 0xfe, 0x28, 0x0c, 0xe3, 0xce, 0x16, 0x6e, + 0xc6, 0x71, 0x7e, 0xf7, 0xfb, 0xc2, 0x60, 0x12, 0xea, 0xfa, 0x53, 0x00, 0x2c, 0x35, 0x42, 0x8f, + 0x07, 0x63, 0x78, 0xff, 0xfb, 0xf7, 0xf9, 0x6d, 0x1c, 0x8f, 0xc5, 0x03, 0x60, 0x77, 0x7b, 0x0e, + 0x06, 0x78, 0x23, 0x08, 0x40, 0x67, 0xe4, 0x09, 0xc8, 0xbf, 0x68, 0x9b, 0x86, 0xa3, 0xb6, 0xe2, + 0xb8, 0xff, 0x07, 0xe7, 0x16, 0xf4, 0x44, 0x60, 0x1d, 0xd3, 0xc2, 0x8e, 0xda, 0xb2, 0xe3, 0x78, + 0xff, 0x27, 0xe7, 0x75, 0x19, 0x08, 0xb3, 0xa6, 0xda, 0x4e, 0x92, 0x71, 0xff, 0x2f, 0xc1, 0x2c, + 0x18, 0x48, 0xa7, 0xc9, 0xef, 0x1b, 0x78, 0x2f, 0x8e, 0xf7, 0xaf, 0x45, 0xa7, 0x39, 0x7d, 0xfd, + 0x7d, 0x50, 0x24, 0x3f, 0xd9, 0x15, 0xbb, 0x18, 0xe6, 0xff, 0xcd, 0x99, 0x3d, 0x0e, 0xd2, 0xb2, + 0xed, 0x34, 0x1d, 0x3d, 0x5e, 0xd8, 0xb7, 0xf9, 0x4c, 0x0b, 0xfa, 0xfa, 0x3c, 0x94, 0x6c, 0xa7, + 0xd9, 0xec, 0xf1, 0xf8, 0x34, 0x86, 0xfd, 0xff, 0x7c, 0xdf, 0x4d, 0x59, 0xb8, 0x3c, 0x64, 0xb6, + 0x6f, 0xdd, 0x70, 0xba, 0x26, 0x3d, 0x02, 0x89, 0x43, 0x78, 0x93, 0x23, 0xf8, 0x58, 0xea, 0x0b, + 0x30, 0x42, 0xc6, 0x62, 0xe1, 0x2e, 0xa6, 0xe7, 0x55, 0x31, 0x10, 0xff, 0x97, 0x0b, 0x20, 0xc0, + 0xd4, 0xf8, 0xd0, 0xd7, 0x5f, 0x9f, 0x49, 0x7d, 0xe3, 0xf5, 0x99, 0xd4, 0x5f, 0xbc, 0x3e, 0x93, + 0xfa, 0xe4, 0xb7, 0x67, 0x86, 0xbe, 0xf1, 0xed, 0x99, 0xa1, 0x3f, 0xfb, 0xf6, 0xcc, 0x50, 0x74, + 0xda, 0x18, 0x2e, 0x9b, 0x97, 0x4d, 0x96, 0x30, 0x7e, 0x41, 0x0a, 0xa4, 0x8b, 0x5b, 0xa6, 0x97, + 0xad, 0x75, 0x37, 0x39, 0xf0, 0x87, 0x69, 0x78, 0x80, 0x5e, 0xf7, 0xb5, 0x3a, 0xba, 0xe1, 0x9c, + 0xd3, 0xac, 0xbd, 0xae, 0x63, 0x9e, 0xeb, 0x60, 0xeb, 0x46, 0x1b, 0xf3, 0x3f, 0x3c, 0xfb, 0x3b, + 0xed, 0x91, 0xcd, 0x31, 0xb2, 0x39, 0xf6, 0xbc, 0x1a, 0x99, 0x2d, 0x96, 0x16, 0x20, 0xbf, 0x66, + 0x99, 0xe6, 0xf6, 0xb5, 0x2e, 0x42, 0xfc, 0x06, 0x33, 0xbf, 0x19, 0x47, 0xd5, 0xb0, 0x02, 0x99, + 0x1b, 0x78, 0x8f, 0x26, 0xce, 0x47, 0x64, 0xf2, 0x93, 0x50, 0x35, 0x55, 0x47, 0xa5, 0x09, 0xf3, + 0x11, 0x99, 0xfe, 0x96, 0x1a, 0x30, 0x4c, 0x41, 0xd0, 0x13, 0x90, 0x31, 0xbb, 0x36, 0xcf, 0xee, + 0x9f, 0x98, 0x1b, 0xd4, 0x97, 0x39, 0xde, 0x64, 0x23, 0xfb, 0xf5, 0xfd, 0xda, 0x90, 0x4c, 0x78, + 0x1a, 0x6b, 0x7f, 0xfb, 0xad, 0x99, 0xd4, 0x17, 0x5e, 0x9f, 0x49, 0x0d, 0x92, 0xe4, 0x0b, 0x73, + 0x3e, 0x41, 0xf9, 0x84, 0x31, 0x48, 0x2e, 0x5b, 0x39, 0x3a, 0xc2, 0x77, 0xc3, 0xcf, 0xa5, 0x61, + 0xc6, 0x47, 0xd4, 0xd6, 0xb7, 0xec, 0x73, 0x37, 0x6e, 0x9e, 0x23, 0xe3, 0xb3, 0xb9, 0xd4, 0x90, + 0xaf, 0xa7, 0xe4, 0xf9, 0xdc, 0x8d, 0x9b, 0x03, 0xe4, 0x35, 0x07, 0xd9, 0x35, 0x55, 0xb7, 0x84, + 0x60, 0x52, 0x9e, 0x60, 0x26, 0xbd, 0xcb, 0xad, 0xa4, 0x8e, 0x15, 0xa4, 0xf3, 0x50, 0x78, 0x66, + 0xf9, 0xb1, 0x0b, 0x49, 0x78, 0x32, 0x9c, 0xa7, 0x21, 0x0b, 0x51, 0x7c, 0x25, 0x42, 0x1c, 0x5f, + 0xfb, 0xf6, 0x4c, 0xca, 0x15, 0xc9, 0x6c, 0xac, 0x48, 0xf8, 0x68, 0x5d, 0x61, 0x7c, 0x32, 0x0d, + 0xb5, 0xf0, 0xa9, 0x00, 0x59, 0x8a, 0xb6, 0xa3, 0x76, 0xba, 0x83, 0xde, 0xe9, 0xba, 0x08, 0xc5, + 0x0d, 0x41, 0x83, 0xa6, 0x21, 0x6f, 0x63, 0xcd, 0x34, 0x9a, 0x36, 0x1d, 0x49, 0x46, 0x16, 0x45, + 0x32, 0x1a, 0x43, 0x35, 0x4c, 0x9b, 0x5f, 0x39, 0x65, 0x85, 0xc6, 0x3f, 0x4e, 0x1d, 0x6e, 0x6d, + 0x94, 0xdd, 0xa6, 0xe8, 0x02, 0x59, 0x4b, 0xbd, 0xf0, 0xe0, 0x41, 0x07, 0x2a, 0x74, 0x1a, 0xbd, + 0x21, 0xf8, 0x4e, 0x4f, 0x66, 0xc2, 0xa7, 0x27, 0xcf, 0xe1, 0x76, 0xfb, 0x19, 0xc3, 0xbc, 0x65, + 0x6c, 0x10, 0x1e, 0x57, 0x24, 0x1f, 0x4f, 0xc3, 0x4c, 0xdf, 0x41, 0x09, 0x37, 0x2f, 0x83, 0x24, + 0x52, 0x87, 0xc2, 0xa2, 0xb0, 0x5a, 0x87, 0x15, 0xc8, 0x2f, 0x1f, 0x52, 0x20, 0xa3, 0xa2, 0x25, + 0x21, 0x8f, 0xb3, 0xf1, 0xf2, 0x10, 0xfd, 0xbf, 0x03, 0x71, 0xfc, 0xd4, 0x93, 0x70, 0xc2, 0xa7, + 0x40, 0xea, 0x96, 0xa6, 0x9f, 0xe3, 0x42, 0xf6, 0xad, 0x98, 0x23, 0xbe, 0x15, 0x43, 0x48, 0xe6, + 0xe8, 0xc3, 0xe8, 0x45, 0x53, 0x4d, 0x66, 0xbb, 0xaa, 0x31, 0xab, 0xb4, 0x1a, 0xa7, 0xb8, 0xd5, + 0x98, 0x69, 0x94, 0xfe, 0x66, 0x18, 0xf2, 0x32, 0x7e, 0xa9, 0x87, 0x6d, 0xfa, 0x4a, 0x22, 0xd6, + 0x76, 0x4c, 0x7e, 0xdb, 0x5d, 0x9a, 0x8b, 0x1c, 0xcf, 0x1c, 0xa7, 0x5e, 0xd2, 0x76, 0xcc, 0x2b, + 0x43, 0x32, 0xe5, 0xa0, 0xef, 0x80, 0xb5, 0x7b, 0xf6, 0x0e, 0xbf, 0x94, 0x7c, 0xf2, 0x60, 0xd6, + 0x4b, 0x84, 0xf4, 0xca, 0x90, 0xcc, 0x78, 0x48, 0xb3, 0xf4, 0xfd, 0xb5, 0x6c, 0x92, 0x66, 0x97, + 0x8d, 0x6d, 0xda, 0x2c, 0xe1, 0x40, 0x57, 0x00, 0x6c, 0xec, 0x88, 0xab, 0x0c, 0xc3, 0x94, 0xff, + 0xf4, 0xc1, 0xfc, 0xeb, 0xd8, 0x61, 0x6e, 0xeb, 0xca, 0x90, 0x5c, 0xb4, 0x45, 0x81, 0x20, 0xe9, + 0x86, 0xee, 0x28, 0xda, 0x8e, 0xaa, 0x1b, 0xf4, 0x0c, 0x3e, 0x16, 0x69, 0xd9, 0xd0, 0x9d, 0x05, + 0x42, 0x4e, 0x90, 0x74, 0x51, 0x20, 0xa2, 0x78, 0xa9, 0x87, 0xf9, 0xdd, 0xb7, 0x58, 0x51, 0x3c, + 0x4b, 0x48, 0x89, 0x28, 0x28, 0x0f, 0x7a, 0x06, 0x4a, 0xf4, 0xb8, 0x55, 0xd9, 0x6a, 0x9b, 0xda, + 0x0d, 0xfe, 0x66, 0xc9, 0xec, 0xc1, 0x10, 0x0d, 0xc2, 0xd0, 0x20, 0xf4, 0x57, 0x86, 0x64, 0xd8, + 0x72, 0x4b, 0xa8, 0x01, 0x05, 0x76, 0xed, 0xd7, 0xd9, 0xe5, 0xef, 0x06, 0x3e, 0x70, 0x30, 0x12, + 0xbd, 0x01, 0xbc, 0xb1, 0x7b, 0x65, 0x48, 0xce, 0x6b, 0xec, 0x27, 0x5a, 0x82, 0x22, 0x36, 0x9a, + 0xbc, 0x3b, 0x25, 0xfe, 0x16, 0xd5, 0xc1, 0x7a, 0x61, 0x34, 0x45, 0x67, 0x0a, 0x98, 0xff, 0x46, + 0x4f, 0x42, 0x4e, 0x33, 0x3b, 0x1d, 0xdd, 0xa1, 0xef, 0x18, 0x96, 0xce, 0xdf, 0x1f, 0xd3, 0x11, + 0x4a, 0x7b, 0x65, 0x48, 0xe6, 0x5c, 0x64, 0x7a, 0x9a, 0xb8, 0xad, 0xdf, 0xc4, 0x16, 0x19, 0xcc, + 0x44, 0x92, 0xe9, 0x59, 0x64, 0xf4, 0x74, 0x38, 0xc5, 0xa6, 0x28, 0x34, 0xf2, 0xdc, 0xbd, 0x48, + 0xa7, 0xa1, 0xe4, 0xd3, 0x64, 0x62, 0xb1, 0xf8, 0x0e, 0x84, 0x3b, 0x7b, 0x51, 0x94, 0xca, 0x30, + 0xe2, 0xd7, 0x5b, 0xa9, 0xe3, 0x32, 0xd2, 0x43, 0xfc, 0x69, 0xc8, 0xdf, 0xc4, 0x96, 0xcd, 0x4e, + 0xf0, 0x29, 0x23, 0x2f, 0xa2, 0x93, 0x30, 0x4a, 0xe5, 0xa6, 0x88, 0xe7, 0x69, 0x7a, 0x61, 0x64, + 0x84, 0x56, 0x5e, 0xe7, 0x44, 0x35, 0x28, 0x75, 0xcf, 0x77, 0x5d, 0x92, 0x0c, 0x25, 0x81, 0xee, + 0xf9, 0x2e, 0x27, 0x90, 0xea, 0x50, 0x09, 0xab, 0xae, 0xdf, 0x6b, 0x16, 0x23, 0xbc, 0x66, 0x51, + 0x78, 0xda, 0xdf, 0x49, 0xbb, 0xcc, 0xae, 0xb6, 0x92, 0xe5, 0x46, 0x8c, 0x04, 0xe5, 0x2e, 0x9d, + 0xaf, 0xf6, 0x85, 0x76, 0xae, 0xaf, 0x69, 0x14, 0x48, 0x28, 0xf2, 0xc9, 0x3f, 0xaf, 0xa5, 0x64, + 0xca, 0x81, 0x8e, 0x11, 0x85, 0x52, 0x75, 0x43, 0xd1, 0x9b, 0xe2, 0x6d, 0x62, 0x5a, 0x5e, 0x6e, + 0xa2, 0x67, 0xa1, 0xa2, 0x99, 0x86, 0x8d, 0x0d, 0xbb, 0x67, 0x2b, 0x5d, 0xd5, 0x52, 0x3b, 0xde, + 0x4b, 0x77, 0xd1, 0xd3, 0xb4, 0x20, 0xc8, 0xd7, 0x28, 0xb5, 0x3c, 0xa6, 0x05, 0x2b, 0xd0, 0x0a, + 0xc0, 0x4d, 0xb5, 0xad, 0x37, 0x55, 0xc7, 0xb4, 0x6c, 0xfe, 0x72, 0xca, 0x20, 0xb0, 0xeb, 0x82, + 0x70, 0xb3, 0xdb, 0x54, 0x1d, 0xcc, 0x83, 0x28, 0x1f, 0x3f, 0x3a, 0x05, 0x63, 0x6a, 0xb7, 0xab, + 0xd8, 0x8e, 0xea, 0x60, 0x65, 0x6b, 0xcf, 0xc1, 0x36, 0xb5, 0x17, 0x23, 0xf2, 0xa8, 0xda, 0xed, + 0xae, 0x93, 0xda, 0x06, 0xa9, 0x94, 0x9a, 0xee, 0x6c, 0xd3, 0xa5, 0xe9, 0xc6, 0x76, 0x29, 0x2f, + 0xb6, 0x23, 0x75, 0xf4, 0x6a, 0x05, 0x93, 0x81, 0xb8, 0x8d, 0x92, 0xdb, 0xc1, 0x7a, 0x6b, 0xc7, + 0xa1, 0xc3, 0xce, 0xc8, 0xbc, 0x44, 0x26, 0xa6, 0x6b, 0x99, 0x37, 0xd9, 0x6d, 0xa1, 0x82, 0xcc, + 0x0a, 0xd2, 0xaf, 0xa4, 0x61, 0xbc, 0x6f, 0xf9, 0x12, 0x5c, 0x7a, 0xc1, 0x9f, 0xb7, 0x45, 0x7e, + 0xa3, 0x8b, 0x04, 0x57, 0x6d, 0xf2, 0x97, 0x56, 0x4a, 0xe7, 0xef, 0x1b, 0x20, 0x81, 0x2b, 0x94, + 0x88, 0x0f, 0x9c, 0xb3, 0xa0, 0x4d, 0xa8, 0xb4, 0x55, 0xdb, 0x51, 0xd8, 0x2a, 0x62, 0x6f, 0x09, + 0x67, 0x0e, 0xb4, 0x04, 0x2b, 0xaa, 0x58, 0x7d, 0x44, 0xb9, 0x39, 0x5c, 0xb9, 0x1d, 0xa8, 0x45, + 0xcf, 0xc3, 0xe4, 0xd6, 0xde, 0xcb, 0xaa, 0xe1, 0xe8, 0x06, 0xbd, 0x6c, 0x14, 0x9c, 0xa3, 0xda, + 0x00, 0xe8, 0xa5, 0x9b, 0x7a, 0x13, 0x1b, 0x9a, 0x98, 0x9c, 0x09, 0x17, 0xc2, 0x9d, 0x3c, 0x5b, + 0x7a, 0x1e, 0xca, 0x41, 0x5b, 0x84, 0xca, 0x90, 0x76, 0x76, 0xb9, 0x44, 0xd2, 0xce, 0x2e, 0x7a, + 0x8c, 0x47, 0xe4, 0x69, 0x7a, 0x5b, 0x6e, 0x90, 0xb3, 0xe0, 0xdc, 0xde, 0xbb, 0x84, 0x92, 0xe4, + 0xae, 0x04, 0xd7, 0x30, 0x84, 0xb1, 0xa5, 0x33, 0x30, 0x16, 0x32, 0x62, 0xbe, 0x69, 0x4d, 0xf9, + 0xa7, 0x55, 0x1a, 0x83, 0xd1, 0x80, 0xad, 0x92, 0xfe, 0x24, 0x07, 0x05, 0x19, 0xdb, 0x5d, 0xa2, + 0xc4, 0xe8, 0x0a, 0x14, 0xf1, 0xae, 0x86, 0xbb, 0x8e, 0xb0, 0x0a, 0x07, 0x19, 0x71, 0xc6, 0xb3, + 0x24, 0xe8, 0x89, 0xb9, 0x72, 0x99, 0xd1, 0x13, 0x01, 0x97, 0x7c, 0x32, 0x0e, 0xc4, 0xef, 0x93, + 0xdf, 0x1b, 0xf4, 0xc9, 0xf7, 0xc7, 0xf0, 0x86, 0x9c, 0xf2, 0x13, 0x01, 0xa7, 0x1c, 0xd7, 0x70, + 0xc0, 0x2b, 0x2f, 0x47, 0x78, 0xe5, 0xb8, 0xe1, 0x0f, 0x70, 0xcb, 0xcb, 0x11, 0x6e, 0x79, 0x36, + 0xb6, 0x2f, 0x91, 0x7e, 0xf9, 0xbd, 0x41, 0xbf, 0x1c, 0x27, 0x8e, 0x90, 0x63, 0x5e, 0x89, 0x72, + 0xcc, 0x67, 0x62, 0x30, 0x06, 0x7a, 0xe6, 0x85, 0x3e, 0xcf, 0x7c, 0x2a, 0x06, 0x2a, 0xc2, 0x35, + 0x2f, 0x07, 0x7c, 0x22, 0x24, 0x92, 0x4d, 0xb4, 0x53, 0x44, 0x97, 0xfa, 0xbd, 0xfc, 0xe9, 0x38, + 0x55, 0x8b, 0x72, 0xf3, 0x4f, 0x85, 0xdc, 0xfc, 0x03, 0x71, 0xa3, 0x0a, 0xf9, 0x79, 0xcf, 0x3b, + 0x9f, 0x21, 0xf6, 0x31, 0xb4, 0x32, 0x88, 0x2d, 0xc5, 0x96, 0x65, 0x5a, 0xdc, 0xf1, 0xb1, 0x82, + 0x34, 0x4b, 0x2c, 0xb6, 0xa7, 0xff, 0x07, 0x78, 0x72, 0xba, 0x68, 0x7d, 0xda, 0x2e, 0x7d, 0x25, + 0xe5, 0xf1, 0x52, 0xcb, 0xe6, 0xb7, 0xf6, 0x45, 0x6e, 0xed, 0x7d, 0x0e, 0x3e, 0x1d, 0x74, 0xf0, + 0x35, 0x28, 0x11, 0x9f, 0x12, 0xf2, 0xdd, 0x6a, 0x57, 0xf8, 0x6e, 0x74, 0x16, 0xc6, 0xa9, 0xfd, + 0x65, 0x61, 0x00, 0x37, 0x24, 0x59, 0x6a, 0x48, 0xc6, 0xc8, 0x03, 0x26, 0x41, 0xe6, 0x28, 0x1e, + 0x86, 0x09, 0x1f, 0x2d, 0xc1, 0xa5, 0xbe, 0x80, 0x39, 0xa9, 0x8a, 0x4b, 0x3d, 0xdf, 0xed, 0x5e, + 0x51, 0xed, 0x1d, 0x69, 0xd5, 0x13, 0x90, 0x17, 0x17, 0x20, 0xc8, 0x6a, 0x66, 0x93, 0x8d, 0x7b, + 0x54, 0xa6, 0xbf, 0x49, 0xac, 0xd0, 0x36, 0x5b, 0xfc, 0x06, 0x24, 0xf9, 0x49, 0xa8, 0xdc, 0xa5, + 0x5d, 0x64, 0x6b, 0x56, 0xfa, 0xfd, 0x94, 0x87, 0xe7, 0x85, 0x0a, 0x51, 0x5e, 0x3d, 0x75, 0x37, + 0xbd, 0x7a, 0xfa, 0x07, 0xf3, 0xea, 0xd2, 0x9b, 0x29, 0x6f, 0x4a, 0x5d, 0x7f, 0x7d, 0x67, 0x22, + 0x20, 0xda, 0xc5, 0xde, 0x04, 0x67, 0x37, 0x75, 0x59, 0x41, 0x84, 0x5a, 0xb9, 0x88, 0x04, 0x45, + 0xde, 0x97, 0xd4, 0x40, 0x8f, 0x52, 0x3f, 0x6f, 0x6e, 0x73, 0xd3, 0x50, 0x8b, 0x49, 0xf4, 0xc8, + 0x8c, 0xda, 0xe7, 0x5f, 0x8a, 0x81, 0xb0, 0xe1, 0x5e, 0x28, 0x92, 0xae, 0xb3, 0xd7, 0x9f, 0x80, + 0xa7, 0x17, 0x45, 0x85, 0xd4, 0x04, 0xd4, 0x6f, 0x63, 0xd0, 0x55, 0xc8, 0xe1, 0x9b, 0xf4, 0x36, + 0x2a, 0x4b, 0x36, 0xdd, 0x3b, 0xd0, 0x11, 0x63, 0xc3, 0x69, 0x4c, 0x13, 0x61, 0x7e, 0x77, 0xbf, + 0x56, 0x61, 0x3c, 0x0f, 0x99, 0x1d, 0xdd, 0xc1, 0x9d, 0xae, 0xb3, 0x27, 0x73, 0x14, 0xe9, 0x67, + 0xd3, 0xc4, 0x1f, 0x06, 0xec, 0x4f, 0xa4, 0x78, 0xc5, 0xa2, 0x49, 0xfb, 0x42, 0xa4, 0x64, 0x22, + 0xbf, 0x0f, 0xa0, 0xa5, 0xda, 0xca, 0x2d, 0xd5, 0x70, 0x70, 0x93, 0xcb, 0xbd, 0xd8, 0x52, 0xed, + 0xe7, 0x68, 0x05, 0x89, 0x37, 0xc9, 0xe3, 0x9e, 0x8d, 0x9b, 0x74, 0x02, 0x32, 0x72, 0xbe, 0xa5, + 0xda, 0x9b, 0x36, 0x6e, 0xfa, 0xc6, 0x9a, 0xbf, 0x1b, 0x63, 0x0d, 0xca, 0xbb, 0x10, 0x96, 0xf7, + 0xc7, 0xd2, 0xde, 0xea, 0xf0, 0xc2, 0x87, 0x1f, 0x4d, 0x59, 0x7c, 0x86, 0xee, 0x29, 0x82, 0x4e, + 0x00, 0x7d, 0x00, 0xc6, 0xdd, 0x55, 0xa9, 0xf4, 0xe8, 0x6a, 0x15, 0x5a, 0x78, 0xb8, 0xc5, 0x5d, + 0xb9, 0x19, 0xac, 0xb6, 0xd1, 0x4f, 0xc2, 0xd1, 0x90, 0x0d, 0x72, 0x1b, 0x48, 0x1f, 0xca, 0x14, + 0x1d, 0x09, 0x9a, 0x22, 0x81, 0xef, 0x49, 0x2f, 0x73, 0x57, 0x56, 0xcd, 0xfd, 0x24, 0x84, 0xf5, + 0xbb, 0xb7, 0x28, 0x9d, 0x90, 0xfe, 0x34, 0x05, 0x63, 0xa1, 0x0e, 0xa2, 0xf7, 0xc0, 0x30, 0xf3, + 0xc0, 0xa9, 0x03, 0x13, 0x21, 0x54, 0xe2, 0x7c, 0x4c, 0x8c, 0x01, 0xcd, 0x43, 0x01, 0xf3, 0xe8, + 0x9a, 0x0b, 0xe5, 0x81, 0x98, 0x20, 0x9c, 0xf3, 0xbb, 0x6c, 0x68, 0x11, 0x8a, 0xae, 0xe8, 0x63, + 0x76, 0x6e, 0xee, 0xcc, 0x71, 0x10, 0x8f, 0x51, 0x5a, 0x80, 0x92, 0xaf, 0x7b, 0xec, 0x5d, 0xc0, + 0x5d, 0xbe, 0xdd, 0x62, 0x01, 0x74, 0xa1, 0xa3, 0xee, 0xd2, 0x9d, 0x16, 0x3a, 0x0a, 0x79, 0xf2, + 0xb0, 0xc5, 0x5f, 0x96, 0xca, 0xc8, 0xb9, 0x8e, 0xba, 0x7b, 0x59, 0xb5, 0xa5, 0x8f, 0xa7, 0xa0, + 0x1c, 0xec, 0x27, 0x7a, 0x10, 0x10, 0xa1, 0x55, 0x5b, 0x58, 0x31, 0x7a, 0x1d, 0xe6, 0x23, 0x05, + 0xe2, 0x58, 0x47, 0xdd, 0x9d, 0x6f, 0xe1, 0xab, 0xbd, 0x0e, 0x6d, 0xda, 0x46, 0xab, 0x50, 0x11, + 0xc4, 0x22, 0xd9, 0xc5, 0xa5, 0x72, 0xac, 0xff, 0x7b, 0x35, 0x9c, 0x80, 0xed, 0x75, 0x5f, 0x25, + 0x7b, 0xdd, 0x32, 0xc3, 0x13, 0x4f, 0xa4, 0x47, 0x61, 0x2c, 0x34, 0x62, 0x24, 0xc1, 0x68, 0xb7, + 0xb7, 0xa5, 0xdc, 0xc0, 0x7b, 0xf4, 0xf5, 0x77, 0xa6, 0xea, 0x45, 0xb9, 0xd4, 0xed, 0x6d, 0x3d, + 0x83, 0xf7, 0x68, 0xee, 0x50, 0xd2, 0xa0, 0x1c, 0xdc, 0x4c, 0x11, 0xc7, 0x61, 0x99, 0x3d, 0xa3, + 0x29, 0x3e, 0x6c, 0x40, 0x0b, 0xe8, 0x22, 0x0c, 0xdf, 0x34, 0x99, 0x36, 0x1f, 0xb4, 0x7b, 0xba, + 0x6e, 0x3a, 0xd8, 0xb7, 0x25, 0x63, 0x3c, 0x92, 0x0d, 0xc3, 0x54, 0x2f, 0x23, 0x0f, 0x2a, 0xae, + 0x03, 0xa8, 0x8e, 0x63, 0xe9, 0x5b, 0x3d, 0x0f, 0x7e, 0x7a, 0xae, 0x3f, 0xad, 0x3f, 0xb7, 0xa6, + 0xea, 0x56, 0xe3, 0x5e, 0xae, 0xd9, 0x93, 0x1e, 0x8f, 0x4f, 0xbb, 0x7d, 0x48, 0xd2, 0x1b, 0x59, + 0xc8, 0xb1, 0xed, 0x26, 0x7a, 0x32, 0x98, 0xfc, 0x28, 0x9d, 0x9f, 0x19, 0xd4, 0x7d, 0x46, 0xc5, + 0x7b, 0xef, 0x46, 0x50, 0xa7, 0xc2, 0x19, 0x85, 0x46, 0xe9, 0xf5, 0xfd, 0x5a, 0x9e, 0x46, 0x1f, + 0xcb, 0x8b, 0x5e, 0x7a, 0x61, 0xd0, 0xee, 0x5a, 0xe4, 0x32, 0xb2, 0x87, 0xce, 0x65, 0x5c, 0x81, + 0x51, 0x5f, 0xb8, 0xa5, 0x37, 0xf9, 0x3e, 0x65, 0xe6, 0xa0, 0x45, 0xb7, 0xbc, 0xc8, 0xfb, 0x5f, + 0x72, 0xc3, 0xb1, 0xe5, 0x26, 0x9a, 0x0d, 0x6e, 0xb2, 0x69, 0xd4, 0xc6, 0xc2, 0x05, 0xdf, 0xbe, + 0x99, 0xbe, 0x93, 0x7f, 0x0f, 0x14, 0xe9, 0x8b, 0xcd, 0x94, 0x84, 0x45, 0x0f, 0x05, 0x52, 0x41, + 0x1f, 0x9e, 0x86, 0x31, 0x2f, 0xb0, 0x61, 0x24, 0x05, 0x86, 0xe2, 0x55, 0x53, 0xc2, 0x47, 0x60, + 0xd2, 0xc0, 0xbb, 0x8e, 0x12, 0xa6, 0x2e, 0x52, 0x6a, 0x44, 0x9e, 0x5d, 0x0f, 0x72, 0x3c, 0x00, + 0x65, 0xcf, 0x84, 0x52, 0x5a, 0x60, 0xa9, 0x0f, 0xb7, 0x96, 0x92, 0x1d, 0x83, 0x82, 0x1b, 0x76, + 0x96, 0x28, 0x41, 0x5e, 0x65, 0xd1, 0xa6, 0x1b, 0xc8, 0x5a, 0xd8, 0xee, 0xb5, 0x1d, 0x0e, 0x32, + 0x42, 0x69, 0x68, 0x20, 0x2b, 0xb3, 0x7a, 0x4a, 0x7b, 0x12, 0x46, 0x85, 0x55, 0x61, 0x74, 0xa3, + 0x94, 0x6e, 0x44, 0x54, 0x52, 0xa2, 0x33, 0x50, 0xe9, 0x5a, 0x66, 0xd7, 0xb4, 0xb1, 0xa5, 0xa8, + 0xcd, 0xa6, 0x85, 0x6d, 0x7b, 0xba, 0xcc, 0xf0, 0x44, 0xfd, 0x3c, 0xab, 0x96, 0xde, 0x05, 0x79, + 0x11, 0x4f, 0x4f, 0xc2, 0x70, 0xc3, 0xb5, 0x90, 0x59, 0x99, 0x15, 0x88, 0x7f, 0x9d, 0xef, 0x76, + 0x79, 0x76, 0x8d, 0xfc, 0x94, 0xda, 0x90, 0xe7, 0x13, 0x16, 0x99, 0x53, 0x59, 0x85, 0x91, 0xae, + 0x6a, 0x91, 0x61, 0xf8, 0x33, 0x2b, 0x83, 0x76, 0x84, 0x6b, 0xaa, 0xe5, 0xac, 0x63, 0x27, 0x90, + 0x60, 0x29, 0x51, 0x7e, 0x56, 0x25, 0x3d, 0x01, 0xa3, 0x01, 0x1a, 0xd2, 0x4d, 0xc7, 0x74, 0xd4, + 0xb6, 0x58, 0xe8, 0xb4, 0xe0, 0xf6, 0x24, 0xed, 0xf5, 0x44, 0xba, 0x08, 0x45, 0x77, 0xae, 0xc8, + 0x46, 0x43, 0x88, 0x22, 0xc5, 0xc5, 0xcf, 0x8a, 0x34, 0x89, 0x64, 0xde, 0xe2, 0x9f, 0x68, 0xca, + 0xc8, 0xac, 0x20, 0x61, 0x9f, 0x61, 0x62, 0xde, 0x0c, 0xbd, 0x17, 0xf2, 0xdc, 0x30, 0xf1, 0xf5, + 0x38, 0x28, 0x5d, 0xb4, 0x46, 0x2d, 0x95, 0x48, 0x17, 0x31, 0xbb, 0xe5, 0x35, 0x93, 0xf6, 0x37, + 0xf3, 0x61, 0x28, 0x08, 0xe3, 0x13, 0xf4, 0x12, 0xac, 0x85, 0xe3, 0x71, 0x5e, 0x82, 0x37, 0xe2, + 0x31, 0x12, 0x6d, 0xb2, 0xf5, 0x96, 0x81, 0x9b, 0x8a, 0xb7, 0x04, 0xf9, 0x0b, 0xb3, 0x63, 0xec, + 0xc1, 0x8a, 0x58, 0x5f, 0xd2, 0x23, 0x90, 0x63, 0x7d, 0x8d, 0x34, 0x71, 0x51, 0xae, 0xf5, 0x3b, + 0x29, 0x28, 0x08, 0xf7, 0x11, 0xc9, 0x14, 0x18, 0x44, 0xfa, 0x4e, 0x07, 0x71, 0xf7, 0x4d, 0xd2, + 0x43, 0x80, 0xa8, 0xa6, 0x28, 0x37, 0x4d, 0x47, 0x37, 0x5a, 0x0a, 0x9b, 0x0b, 0xfe, 0xde, 0x20, + 0x7d, 0x72, 0x9d, 0x3e, 0x58, 0x23, 0xf5, 0x67, 0x4f, 0x42, 0xc9, 0x97, 0xe5, 0x42, 0x79, 0xc8, + 0x5c, 0xc5, 0xb7, 0x2a, 0x43, 0xa8, 0x04, 0x79, 0x19, 0xd3, 0x1c, 0x41, 0x25, 0x75, 0xfe, 0x8d, + 0x3c, 0x8c, 0xcd, 0x37, 0x16, 0x96, 0xe7, 0xbb, 0xdd, 0xb6, 0xce, 0xdf, 0xa7, 0xbb, 0x06, 0x59, + 0xba, 0x4f, 0x4e, 0x70, 0xbe, 0x53, 0x4d, 0x92, 0x70, 0x42, 0x32, 0x0c, 0xd3, 0xed, 0x34, 0x4a, + 0x72, 0xec, 0x53, 0x4d, 0x94, 0x87, 0x22, 0x9d, 0xa4, 0x0a, 0x97, 0xe0, 0x34, 0xa8, 0x9a, 0x24, + 0x39, 0x85, 0x7e, 0x12, 0x8a, 0xde, 0x3e, 0x39, 0xe9, 0x19, 0x51, 0x35, 0x71, 0xda, 0x8a, 0xe0, + 0x7b, 0x3b, 0x83, 0xa4, 0x47, 0x13, 0xd5, 0xc4, 0xf9, 0x1a, 0xf4, 0x3c, 0xe4, 0xc5, 0x1e, 0x2c, + 0xd9, 0x29, 0x4e, 0x35, 0x61, 0x4a, 0x89, 0x4c, 0x1f, 0xdb, 0x3a, 0x27, 0x39, 0xaa, 0xaa, 0x26, + 0xca, 0x9b, 0xa1, 0x4d, 0xc8, 0xf1, 0xe0, 0x37, 0xd1, 0x49, 0x4f, 0x35, 0x59, 0xa2, 0x88, 0x08, + 0xd9, 0x4b, 0x4e, 0x24, 0x3d, 0x9e, 0xab, 0x26, 0x4e, 0x18, 0x22, 0x15, 0xc0, 0xb7, 0x9f, 0x4e, + 0x7c, 0xee, 0x56, 0x4d, 0x9e, 0x08, 0x44, 0x1f, 0x84, 0x82, 0xbb, 0x6b, 0x4a, 0x78, 0x92, 0x56, + 0x4d, 0x9a, 0x8b, 0x6b, 0x6c, 0x26, 0xbe, 0x25, 0xf1, 0x60, 0xec, 0x2d, 0x09, 0xef, 0x90, 0xdb, + 0x3d, 0x06, 0xff, 0xf5, 0x3c, 0x4c, 0x68, 0xa6, 0xdd, 0x31, 0xed, 0x73, 0xec, 0x0f, 0x3f, 0xf8, + 0xce, 0xb1, 0xd2, 0x80, 0x93, 0xee, 0xf8, 0x93, 0x73, 0xe9, 0x32, 0x64, 0x17, 0x4c, 0x9d, 0xfa, + 0xf7, 0x26, 0x36, 0xcc, 0x8e, 0x48, 0xf0, 0xd1, 0x02, 0x3a, 0x09, 0x39, 0xb5, 0x63, 0xf6, 0x0c, + 0x47, 0x84, 0x88, 0xc4, 0x6e, 0xfe, 0x97, 0xfd, 0x5a, 0x66, 0xd9, 0x70, 0x64, 0xfe, 0xa8, 0x9e, + 0xfd, 0xab, 0xd7, 0x6a, 0x29, 0xe9, 0x69, 0xc8, 0x2f, 0x62, 0xed, 0x4e, 0xb0, 0x16, 0xb1, 0x16, + 0xc2, 0x3a, 0x03, 0x85, 0x65, 0xc3, 0x61, 0x5f, 0xc8, 0xba, 0x0f, 0x32, 0xba, 0xc1, 0xce, 0x00, + 0x42, 0xed, 0x93, 0x7a, 0x42, 0xba, 0x88, 0x35, 0x97, 0xb4, 0x89, 0xb5, 0x30, 0x29, 0x81, 0x27, + 0xf5, 0x52, 0x03, 0x46, 0xae, 0xab, 0x6d, 0x1e, 0xdb, 0x60, 0x1b, 0x3d, 0x04, 0x45, 0x55, 0x14, + 0xe8, 0x36, 0x62, 0xa4, 0x51, 0xfe, 0xde, 0x7e, 0x0d, 0x3c, 0x22, 0xd9, 0x23, 0xa8, 0x67, 0x5f, + 0xf9, 0xaf, 0xc7, 0x53, 0x92, 0x09, 0xf9, 0xcb, 0xaa, 0x4d, 0xcd, 0xda, 0x85, 0x40, 0xd6, 0x80, + 0x86, 0x45, 0x8d, 0x23, 0xb7, 0xf7, 0x6b, 0xe3, 0x7b, 0x6a, 0xa7, 0x5d, 0x97, 0xbc, 0x67, 0x92, + 0x3f, 0x99, 0x30, 0xe7, 0x4b, 0x26, 0xd0, 0xb0, 0xa9, 0x31, 0x71, 0x7b, 0xbf, 0x36, 0xe6, 0xf1, + 0x90, 0x27, 0x92, 0x9b, 0x61, 0x90, 0xba, 0x90, 0x63, 0x11, 0x5e, 0xe4, 0x71, 0x18, 0xcf, 0x6f, + 0xa4, 0xbd, 0xfc, 0x46, 0xfd, 0x50, 0x7b, 0x6a, 0x1e, 0x84, 0x30, 0x8e, 0x7a, 0xf6, 0xa3, 0xaf, + 0xd5, 0x86, 0x24, 0x0b, 0xd0, 0xba, 0xde, 0xe9, 0xb5, 0xd9, 0x5b, 0xce, 0xe2, 0x5c, 0xe5, 0x02, + 0xeb, 0x37, 0xcd, 0x9d, 0xb0, 0xe8, 0x63, 0x6c, 0x8e, 0x6b, 0x22, 0x17, 0x08, 0x73, 0xaa, 0xdf, + 0xd8, 0xaf, 0xa5, 0x68, 0xef, 0xa9, 0x8c, 0x4e, 0x41, 0x8e, 0xc5, 0xad, 0xdc, 0xd9, 0x97, 0x05, + 0x0f, 0x1b, 0x93, 0xcc, 0x9f, 0x4a, 0x4f, 0x42, 0x7e, 0xd5, 0x6e, 0x2d, 0x92, 0x21, 0x1d, 0x83, + 0x42, 0xc7, 0x6e, 0x29, 0xbe, 0xd0, 0x21, 0xdf, 0xb1, 0x5b, 0x1b, 0x03, 0x42, 0x0e, 0x3e, 0x2d, + 0xef, 0x86, 0xdc, 0xc6, 0x2e, 0x65, 0x3f, 0xe9, 0x4a, 0x29, 0xe3, 0xef, 0x23, 0x47, 0xf7, 0x33, + 0x35, 0x16, 0xff, 0xec, 0x5b, 0x33, 0x43, 0xaf, 0xbc, 0x3e, 0x33, 0x34, 0xf0, 0x8e, 0x97, 0xff, + 0x32, 0x5c, 0x60, 0xf5, 0x3d, 0x6c, 0x37, 0x6f, 0x84, 0x56, 0xe8, 0xc7, 0xde, 0x0f, 0xf7, 0x72, + 0x1a, 0xdb, 0x51, 0x6f, 0xe8, 0x46, 0x4b, 0xfc, 0xe5, 0x4b, 0xb5, 0xcc, 0xbb, 0xc2, 0x6b, 0xef, + 0x78, 0xc9, 0xfe, 0xc0, 0x17, 0x4f, 0xaa, 0x51, 0x96, 0x44, 0xda, 0xcf, 0x02, 0x5a, 0xb5, 0x5b, + 0x0b, 0x16, 0x66, 0x1f, 0x2c, 0xe0, 0xb1, 0x56, 0xf0, 0x85, 0x01, 0x3e, 0xf5, 0xf7, 0xcc, 0x05, + 0xc7, 0xe2, 0x7e, 0x7b, 0xd6, 0xdb, 0x67, 0x06, 0x5e, 0x33, 0x58, 0x02, 0xa0, 0x5b, 0x34, 0xdb, + 0xf6, 0x12, 0x02, 0xb5, 0x30, 0xc6, 0x82, 0x4b, 0x21, 0xab, 0x0e, 0xb6, 0x45, 0xca, 0xd9, 0x63, + 0x44, 0x1f, 0x86, 0x89, 0x8e, 0x6e, 0x28, 0x36, 0x6e, 0x6f, 0x2b, 0x4d, 0xdc, 0xa6, 0x9f, 0x73, + 0xe0, 0xc9, 0xff, 0x62, 0x63, 0x85, 0xaf, 0xf7, 0x53, 0xf1, 0x73, 0x36, 0xb7, 0x6c, 0x38, 0xb7, + 0xf7, 0x6b, 0x55, 0xb6, 0xe8, 0x22, 0x20, 0x25, 0x79, 0xbc, 0xa3, 0x1b, 0xeb, 0xb8, 0xbd, 0xbd, + 0xe8, 0xd6, 0xa1, 0x97, 0x61, 0x9c, 0x53, 0x98, 0xde, 0xc6, 0x89, 0x84, 0x9a, 0x23, 0x8d, 0xd5, + 0xdb, 0xfb, 0xb5, 0x69, 0x86, 0xd6, 0x47, 0x22, 0x7d, 0x6f, 0xbf, 0xf6, 0x70, 0x82, 0x3e, 0xcd, + 0x6b, 0x9a, 0xb0, 0x3a, 0x15, 0x17, 0x84, 0xd7, 0x90, 0xb6, 0xbd, 0x24, 0x9f, 0x68, 0x7b, 0x38, + 0xdc, 0x76, 0x1f, 0x49, 0xd2, 0xb6, 0x7d, 0x16, 0xcf, 0xcb, 0x02, 0x8a, 0xb6, 0xa7, 0x80, 0x6c, + 0x52, 0x44, 0x26, 0xbe, 0x28, 0xf3, 0x12, 0x9a, 0xf5, 0x27, 0xe3, 0x4b, 0xe7, 0x47, 0xc4, 0x7c, + 0x12, 0x17, 0xe0, 0xa6, 0x4a, 0xe8, 0x95, 0x5c, 0x66, 0xd4, 0xbf, 0x92, 0x81, 0xca, 0xaa, 0xdd, + 0x5a, 0x6a, 0xea, 0xce, 0x5d, 0x56, 0xaf, 0x6e, 0x94, 0x74, 0xa8, 0x91, 0x68, 0x2c, 0xdc, 0xde, + 0xaf, 0x95, 0x99, 0x74, 0xee, 0xa6, 0x4c, 0x3a, 0x30, 0xe6, 0xe9, 0xa5, 0x62, 0xa9, 0x0e, 0xff, + 0x7e, 0x49, 0x63, 0x31, 0xa1, 0x06, 0x2e, 0x62, 0xed, 0xf6, 0x7e, 0x6d, 0x8a, 0xf5, 0x2c, 0x04, + 0x25, 0xc9, 0x65, 0x2d, 0xb0, 0x16, 0xd0, 0x6e, 0xb4, 0xe2, 0xd3, 0x1c, 0x76, 0xe3, 0xca, 0x5b, + 0xa8, 0xf4, 0x7c, 0xea, 0xfe, 0x20, 0x0d, 0x25, 0x62, 0x41, 0x59, 0x3d, 0x8e, 0x5e, 0x0a, 0xa9, + 0x1f, 0xe2, 0x52, 0x48, 0xbf, 0x3d, 0x4b, 0xe1, 0xac, 0x1b, 0xc2, 0x64, 0x06, 0xea, 0x7c, 0x30, + 0x92, 0xf9, 0x8f, 0x19, 0x6a, 0x55, 0x69, 0x14, 0x2a, 0xe3, 0xe6, 0x3b, 0x41, 0x80, 0x3f, 0x9d, + 0x82, 0x23, 0x9e, 0x78, 0x6c, 0x4b, 0x0b, 0x49, 0xf1, 0xd9, 0xdb, 0xfb, 0xb5, 0x7b, 0xc3, 0x52, + 0xf4, 0x91, 0xdd, 0x81, 0x24, 0x27, 0x5c, 0xa0, 0x75, 0x4b, 0x8b, 0xee, 0x47, 0xd3, 0x76, 0xdc, + 0x7e, 0x64, 0x06, 0xf7, 0xc3, 0x47, 0xf6, 0x03, 0xf5, 0x63, 0xd1, 0x76, 0xfa, 0x27, 0x35, 0x9b, + 0x70, 0x52, 0xbf, 0x9a, 0x86, 0xd1, 0x55, 0xbb, 0xb5, 0x69, 0x34, 0x7f, 0xbc, 0x20, 0x0e, 0xbb, + 0x20, 0x3e, 0x9e, 0x82, 0xf2, 0x15, 0xdd, 0x76, 0x4c, 0x4b, 0xd7, 0xd4, 0x36, 0x0d, 0x12, 0xbd, + 0x7b, 0x56, 0xa9, 0xc3, 0xdf, 0xb3, 0x7a, 0x1c, 0x72, 0x37, 0xd5, 0xb6, 0x8d, 0x1d, 0x9e, 0x65, + 0x3f, 0x16, 0xf6, 0x1d, 0xe1, 0x3c, 0x12, 0x27, 0xe7, 0xdd, 0xf9, 0xed, 0x34, 0x8c, 0x85, 0x02, + 0x0f, 0xd4, 0x80, 0x2c, 0xb5, 0xe8, 0x6c, 0x1f, 0x31, 0x77, 0x88, 0xb8, 0x82, 0x6c, 0x35, 0x28, + 0x2f, 0xfa, 0x09, 0x28, 0x74, 0xd4, 0x5d, 0xe6, 0x19, 0xd8, 0x76, 0x67, 0xfe, 0x70, 0x38, 0xde, + 0xa6, 0x40, 0xe0, 0x48, 0x72, 0xbe, 0xa3, 0xee, 0x52, 0x7f, 0xd0, 0x85, 0x31, 0x52, 0xab, 0xed, + 0xa8, 0x46, 0x0b, 0xfb, 0xdd, 0xcf, 0x95, 0x43, 0x37, 0x32, 0xe5, 0x35, 0xe2, 0x83, 0x93, 0xe4, + 0xd1, 0x8e, 0xba, 0xbb, 0x40, 0x2b, 0x48, 0x8b, 0xf5, 0xc2, 0xab, 0xaf, 0xd5, 0x86, 0xa8, 0xc4, + 0xfe, 0x7d, 0x0a, 0xc0, 0x93, 0x18, 0xda, 0x80, 0x4a, 0xc8, 0x7d, 0x89, 0x7b, 0x0a, 0xb1, 0x01, + 0x9e, 0xb7, 0x5f, 0x18, 0xd3, 0x42, 0x53, 0xf0, 0x41, 0x28, 0xb1, 0x93, 0x46, 0x85, 0x26, 0xf4, + 0xd2, 0xb1, 0x09, 0xbd, 0x19, 0x82, 0x75, 0x7b, 0xbf, 0x86, 0xd8, 0x70, 0x7c, 0xcc, 0x12, 0x4d, + 0xf3, 0x01, 0xab, 0x21, 0x0c, 0xc1, 0xb1, 0x94, 0x7c, 0xb1, 0x05, 0xbd, 0xbf, 0x62, 0x1a, 0xfa, + 0x0d, 0x6c, 0xb9, 0x5b, 0x0f, 0x56, 0x44, 0x55, 0x28, 0xb0, 0x2f, 0x93, 0x39, 0x7b, 0xe2, 0x93, + 0xf7, 0xa2, 0x4c, 0xb8, 0x6e, 0xe1, 0x2d, 0x5b, 0x17, 0xb3, 0x20, 0x8b, 0x22, 0xba, 0x04, 0x15, + 0x1b, 0x6b, 0x3d, 0x4b, 0x77, 0xf6, 0x14, 0xcd, 0x34, 0x1c, 0x55, 0x73, 0xb8, 0xd3, 0xbe, 0xe7, + 0xf6, 0x7e, 0xed, 0x28, 0xeb, 0x6b, 0x98, 0x42, 0x92, 0xc7, 0x44, 0xd5, 0x02, 0xab, 0x21, 0x2d, + 0x34, 0xb1, 0xa3, 0xea, 0x6d, 0x16, 0xf4, 0x15, 0x65, 0x51, 0xf4, 0x8d, 0xe5, 0x4b, 0x79, 0x7f, + 0x42, 0xfb, 0x16, 0x54, 0xcc, 0x2e, 0xb6, 0x22, 0xec, 0xd1, 0x8a, 0xd7, 0x72, 0x98, 0xe2, 0x0e, + 0x4c, 0xc2, 0x98, 0xc0, 0x10, 0x16, 0xe1, 0x52, 0xe0, 0xde, 0x0a, 0x8b, 0x1b, 0xd3, 0xe1, 0x21, + 0x87, 0x29, 0x24, 0xff, 0x65, 0x15, 0x16, 0x5d, 0x4e, 0x41, 0xee, 0x45, 0x55, 0x6f, 0x8b, 0xcf, + 0x35, 0xca, 0xbc, 0x84, 0x96, 0x21, 0x67, 0x3b, 0xaa, 0xd3, 0x63, 0xa1, 0xf7, 0x70, 0xe3, 0x5d, + 0x09, 0xfb, 0xdc, 0x30, 0x8d, 0xe6, 0x3a, 0x65, 0x94, 0x39, 0x00, 0xba, 0x04, 0x39, 0xc7, 0xbc, + 0x81, 0x0d, 0x2e, 0xd4, 0x43, 0xad, 0x74, 0x9a, 0xff, 0x60, 0xdc, 0xc8, 0x01, 0xcf, 0x28, 0x2b, + 0xf6, 0x8e, 0x6a, 0x61, 0x9b, 0x85, 0xca, 0x8d, 0xe5, 0x43, 0x2f, 0xc7, 0xa3, 0x61, 0x4f, 0xc1, + 0xf0, 0x24, 0x79, 0xcc, 0xad, 0x5a, 0xa7, 0x35, 0xe1, 0xc8, 0x39, 0x7f, 0x47, 0x91, 0xf3, 0x25, + 0xa8, 0xf4, 0x8c, 0x2d, 0xd3, 0xa0, 0x9f, 0x56, 0xe3, 0x39, 0xf5, 0xc2, 0xf1, 0xd4, 0x6c, 0xc6, + 0x3f, 0x5b, 0x61, 0x0a, 0x49, 0x1e, 0x73, 0xab, 0xf8, 0x0d, 0xaa, 0x26, 0x94, 0x3d, 0x2a, 0xba, + 0x64, 0x8b, 0xb1, 0x4b, 0xf6, 0x04, 0x5f, 0xb2, 0x47, 0xc2, 0xad, 0x78, 0xab, 0x76, 0xd4, 0xad, + 0x24, 0x6c, 0xe8, 0xfd, 0x81, 0x6d, 0x24, 0xf0, 0x16, 0x06, 0x5a, 0x99, 0xe4, 0x3b, 0xc8, 0xd2, + 0xdb, 0xb2, 0x83, 0xac, 0x8f, 0x7c, 0xf4, 0xb5, 0xda, 0x90, 0xbb, 0x60, 0x7f, 0x2e, 0x0d, 0xb9, + 0xc5, 0xeb, 0xf4, 0x55, 0xac, 0x1f, 0xd1, 0xf0, 0xc1, 0x67, 0xbd, 0xde, 0x07, 0x79, 0x26, 0x0b, + 0x1b, 0x9d, 0x87, 0xe1, 0x2e, 0xf9, 0xc1, 0x53, 0x38, 0x53, 0x7d, 0x2a, 0x4d, 0xe9, 0xc4, 0x0e, + 0x93, 0x92, 0x4a, 0x9f, 0xcb, 0x00, 0x2c, 0x5e, 0xbf, 0xbe, 0x61, 0xe9, 0xdd, 0x36, 0x76, 0x7e, + 0x1c, 0x5e, 0xbf, 0x73, 0xc2, 0x6b, 0xdf, 0x1c, 0x3f, 0x03, 0x25, 0x6f, 0x8e, 0x6c, 0xf4, 0x5e, + 0x28, 0x38, 0xfc, 0x37, 0x9f, 0xea, 0x6a, 0xff, 0x54, 0x0b, 0x72, 0x3e, 0xdd, 0x2e, 0x87, 0xf4, + 0x9f, 0xd3, 0x00, 0x71, 0xc9, 0x99, 0x1f, 0x81, 0x00, 0xfc, 0x12, 0xe4, 0xb8, 0xc7, 0xc9, 0xdc, + 0x51, 0xb4, 0xca, 0xb9, 0x7d, 0xb3, 0xf4, 0xad, 0x34, 0x4c, 0x6c, 0x0a, 0xb3, 0xfb, 0x63, 0x09, + 0xa3, 0x2b, 0x90, 0xc7, 0x86, 0x63, 0xe9, 0x58, 0x64, 0xd4, 0x67, 0xc3, 0x5a, 0x1a, 0x21, 0x2d, + 0xfa, 0xc9, 0x75, 0x71, 0xe3, 0x86, 0xb3, 0xfb, 0x64, 0xfc, 0x89, 0x0c, 0x4c, 0x0f, 0xe2, 0x42, + 0x0b, 0x30, 0xa6, 0x59, 0x98, 0x56, 0x28, 0xfe, 0x17, 0x20, 0x1a, 0x55, 0x5f, 0xc6, 0x28, 0x48, + 0x20, 0xc9, 0x65, 0x51, 0xc3, 0x1d, 0x72, 0x8b, 0x26, 0xa8, 0xc8, 0x52, 0x21, 0x54, 0x09, 0x83, + 0x68, 0x89, 0x7b, 0x64, 0x2f, 0x2d, 0xe5, 0x07, 0x60, 0x2e, 0xb9, 0xec, 0xd5, 0x52, 0x9f, 0xfc, + 0x12, 0x8c, 0xe9, 0x86, 0xee, 0xe8, 0x6a, 0x5b, 0xd9, 0x52, 0xdb, 0xaa, 0xa1, 0xdd, 0xc9, 0x56, + 0x84, 0x79, 0x53, 0xde, 0x6c, 0x08, 0x4e, 0x92, 0xcb, 0xbc, 0xa6, 0xc1, 0x2a, 0xc8, 0x8c, 0x88, + 0xa6, 0xb2, 0x77, 0x14, 0xb8, 0x09, 0x76, 0xdf, 0x8c, 0xfc, 0x7c, 0x06, 0xc6, 0xdd, 0xfc, 0xcc, + 0x8f, 0xa7, 0x22, 0xe9, 0x54, 0xac, 0x02, 0x30, 0x03, 0x42, 0x3c, 0xc7, 0x1d, 0xcc, 0x06, 0x31, + 0x41, 0x45, 0x86, 0xb0, 0x68, 0x3b, 0xbe, 0xf9, 0xf8, 0xcb, 0x0c, 0x8c, 0xf8, 0xe7, 0xe3, 0xc7, + 0x2e, 0xfd, 0x1d, 0x94, 0x31, 0x9b, 0xf7, 0x4c, 0x62, 0x96, 0x7f, 0x5b, 0x21, 0x64, 0x12, 0xfb, + 0x96, 0xd2, 0x60, 0x5b, 0xf8, 0x37, 0x69, 0xc8, 0xf1, 0xbb, 0x9d, 0x5a, 0xdf, 0x2e, 0x22, 0x15, + 0x77, 0x77, 0xf4, 0xe0, 0x4d, 0xc4, 0xab, 0x91, 0x9b, 0x88, 0x72, 0x47, 0xdd, 0x55, 0x02, 0x6f, + 0x42, 0xa4, 0x66, 0x47, 0x1b, 0xc7, 0x3c, 0x94, 0xe0, 0x73, 0x96, 0x0b, 0xf1, 0xee, 0xf5, 0xa1, + 0xc7, 0xa1, 0x44, 0x28, 0x3c, 0xaf, 0x40, 0xd8, 0xa7, 0xbc, 0xe4, 0x83, 0xef, 0xa1, 0x24, 0x43, + 0x47, 0xdd, 0x5d, 0x62, 0x05, 0xb4, 0x02, 0x68, 0xc7, 0x4d, 0x7d, 0x29, 0x9e, 0x08, 0x09, 0xff, + 0x7d, 0xb7, 0xf7, 0x6b, 0xc7, 0x18, 0x7f, 0x3f, 0x8d, 0x24, 0x8f, 0x7b, 0x95, 0x02, 0xed, 0x02, + 0x00, 0x19, 0x97, 0xc2, 0x8e, 0xda, 0xd9, 0x16, 0xd6, 0x77, 0xfe, 0xec, 0x3d, 0x93, 0xe4, 0x22, + 0x29, 0x2c, 0x92, 0xdf, 0x3e, 0xc1, 0xff, 0x42, 0x0a, 0x90, 0xe7, 0x7b, 0xdc, 0x83, 0xde, 0xf7, + 0xd3, 0x77, 0x9b, 0xc4, 0xce, 0x28, 0x15, 0xbd, 0xc9, 0xf2, 0xf8, 0xc4, 0x26, 0xcb, 0xb7, 0x54, + 0x1f, 0xf2, 0xec, 0x73, 0x7a, 0x60, 0x56, 0x30, 0xc2, 0x06, 0xff, 0xdb, 0x14, 0x1c, 0xeb, 0x53, + 0x1c, 0xb7, 0x5f, 0xd7, 0x01, 0x59, 0xbe, 0x87, 0xfc, 0xbf, 0x9c, 0xa4, 0xf8, 0x7f, 0x0d, 0x4b, + 0xa8, 0x7f, 0xe3, 0x56, 0x9f, 0x8d, 0xbf, 0x7b, 0xde, 0x84, 0x67, 0x14, 0x53, 0x30, 0xe9, 0x6f, + 0xde, 0x1d, 0xc0, 0x25, 0x18, 0xf1, 0xb7, 0xce, 0xbb, 0x7e, 0xef, 0x41, 0x5d, 0xe7, 0xbd, 0x0e, + 0xf0, 0xa1, 0x65, 0x6f, 0xf5, 0x89, 0x7f, 0x5c, 0x17, 0x37, 0x7a, 0xf7, 0x32, 0x4c, 0x68, 0x15, + 0xb2, 0x1e, 0xff, 0xbf, 0x14, 0x64, 0xd7, 0x4c, 0xb3, 0x8d, 0x4c, 0x18, 0x37, 0x4c, 0x47, 0x21, + 0xca, 0x82, 0x9b, 0x0a, 0xcf, 0x8d, 0xb0, 0x2c, 0xe8, 0xc2, 0xe1, 0x84, 0xf2, 0xdd, 0xfd, 0x5a, + 0x3f, 0x94, 0x3c, 0x66, 0x98, 0x4e, 0x83, 0xd6, 0x6c, 0xb0, 0xcc, 0xc9, 0x87, 0x61, 0x34, 0xd8, + 0x18, 0xcb, 0x14, 0x3d, 0x77, 0xe8, 0xc6, 0x82, 0x30, 0xb7, 0xf7, 0x6b, 0x93, 0xde, 0x22, 0x70, + 0xab, 0x25, 0x79, 0x64, 0xcb, 0xd7, 0x7a, 0xbd, 0x40, 0x46, 0xff, 0xd7, 0xaf, 0xd5, 0x52, 0x8d, + 0x4b, 0x03, 0x6f, 0x00, 0x3c, 0x74, 0x60, 0x17, 0x76, 0xdd, 0xa3, 0xfe, 0xe0, 0x5d, 0x80, 0x2f, + 0xa6, 0xe1, 0x3e, 0x4e, 0x4d, 0xdf, 0x61, 0x3c, 0xd7, 0x55, 0x5b, 0xba, 0xe1, 0xff, 0x84, 0xc7, + 0x08, 0x9f, 0x32, 0xfa, 0x58, 0x32, 0xa0, 0xb4, 0xa6, 0xb6, 0xb0, 0xf8, 0x18, 0x44, 0xff, 0x97, + 0x59, 0xa6, 0x20, 0x67, 0x6e, 0x6f, 0xb3, 0x2c, 0x77, 0x6a, 0x36, 0x2b, 0xf3, 0x12, 0x9a, 0x84, + 0xe1, 0xb6, 0xde, 0xd1, 0x1d, 0xfe, 0x02, 0x1c, 0x2b, 0xa0, 0x1a, 0x94, 0x34, 0xb3, 0x67, 0x38, + 0x0a, 0xbb, 0x0a, 0x9b, 0x15, 0xdf, 0x05, 0xed, 0x19, 0xce, 0x06, 0xa9, 0x91, 0x9e, 0x82, 0x11, + 0xd6, 0x1e, 0x57, 0xcd, 0x63, 0x50, 0xa0, 0xf7, 0x9a, 0xbd, 0x56, 0xf3, 0xa4, 0xcc, 0x2f, 0xa6, + 0x32, 0x14, 0xd6, 0x30, 0x2b, 0x34, 0x1a, 0x03, 0x05, 0x36, 0x1b, 0x3f, 0x67, 0x4c, 0x26, 0xae, + 0xb0, 0x7e, 0x65, 0x0e, 0xaa, 0xa1, 0x8b, 0x13, 0x94, 0x60, 0xc0, 0xb5, 0x89, 0x83, 0x05, 0x3b, + 0xe0, 0x56, 0xc5, 0x81, 0x37, 0x33, 0xa4, 0x0f, 0xc1, 0x14, 0xbd, 0x3b, 0xe7, 0xd9, 0x78, 0x31, + 0x13, 0x53, 0x6e, 0xb6, 0x31, 0xc5, 0xff, 0x41, 0x33, 0x4b, 0x1d, 0x3e, 0x08, 0x19, 0x0b, 0xbf, + 0xe4, 0xbe, 0xda, 0xe0, 0x9f, 0xcc, 0x39, 0xdf, 0x4c, 0xca, 0x84, 0x4a, 0xfa, 0x68, 0x0a, 0x8e, + 0xf6, 0xe1, 0x73, 0xc9, 0x3f, 0x15, 0x78, 0x27, 0x2f, 0x95, 0xec, 0x08, 0xc3, 0xff, 0x72, 0xfd, + 0x43, 0xa4, 0x27, 0xb6, 0x1b, 0x51, 0x46, 0xf4, 0x84, 0xb5, 0x44, 0xba, 0x62, 0x4b, 0x2f, 0xc1, + 0x91, 0x60, 0x4f, 0xc4, 0x40, 0x9f, 0x87, 0x72, 0x70, 0xfb, 0xc4, 0x63, 0xab, 0x77, 0x1d, 0x3e, + 0x64, 0x18, 0x0d, 0x6c, 0xa1, 0xa4, 0xe7, 0xc2, 0xc2, 0x75, 0xc7, 0xfe, 0xbe, 0xfe, 0x1b, 0xcd, + 0xb1, 0x43, 0xf7, 0xbd, 0xf0, 0xf2, 0x9b, 0x29, 0x38, 0x1e, 0x44, 0xf6, 0xbc, 0x92, 0xfd, 0x96, + 0x8f, 0xeb, 0x70, 0x2a, 0xf0, 0x47, 0x29, 0x38, 0x71, 0x40, 0x5f, 0xb9, 0x40, 0x2c, 0x98, 0xf4, + 0x39, 0x38, 0x8b, 0x57, 0x0b, 0xb5, 0x90, 0x06, 0x3b, 0x61, 0xd7, 0xbe, 0xdf, 0x43, 0x84, 0xf4, + 0xc5, 0x3f, 0xaf, 0x4d, 0xf4, 0x3f, 0xb3, 0xe5, 0x89, 0x7e, 0xa7, 0x74, 0x58, 0xfd, 0xf9, 0xbd, + 0x14, 0x9c, 0x09, 0x8e, 0x23, 0x62, 0x1b, 0xfb, 0x4e, 0x13, 0xfe, 0x97, 0x53, 0x70, 0x36, 0x49, + 0xa7, 0xf9, 0x2c, 0xbc, 0x00, 0x13, 0x5e, 0x18, 0x19, 0x9e, 0x84, 0x93, 0x09, 0x36, 0xff, 0x5c, + 0x55, 0x91, 0x8b, 0x72, 0xa7, 0xd2, 0xfe, 0x93, 0x14, 0x5f, 0x3b, 0xfe, 0xd9, 0x74, 0x45, 0x1b, + 0xdc, 0xeb, 0x1c, 0x52, 0xb4, 0xbe, 0xfd, 0xce, 0x68, 0x60, 0xbf, 0x13, 0x31, 0x69, 0xe9, 0xbb, + 0x64, 0x09, 0x7e, 0x46, 0xd8, 0xc1, 0x88, 0xa8, 0xf3, 0x06, 0x4c, 0x44, 0xa8, 0xbe, 0xfb, 0x3a, + 0x5e, 0xbc, 0xe6, 0x4f, 0x7d, 0x6f, 0xbf, 0x16, 0x11, 0xce, 0xca, 0xa8, 0x5f, 0xe9, 0xa5, 0xff, + 0x94, 0x82, 0x1a, 0xed, 0x48, 0xc4, 0xe4, 0xfd, 0x5d, 0x16, 0x30, 0xe6, 0x06, 0x31, 0x72, 0x58, + 0x5c, 0xd0, 0xf3, 0x90, 0x63, 0x7a, 0xc9, 0x65, 0x7b, 0x08, 0x85, 0xe6, 0x8c, 0x9e, 0xe1, 0x5d, + 0x14, 0xe3, 0x8a, 0x5e, 0xfb, 0x6f, 0x91, 0xfc, 0x0e, 0xb5, 0xf6, 0xbf, 0x24, 0x0c, 0x6f, 0x74, + 0x5f, 0xb9, 0x50, 0x3e, 0xf8, 0x03, 0x1b, 0x5e, 0xfe, 0x61, 0x95, 0xbb, 0x68, 0x61, 0xdd, 0x0e, + 0xc7, 0x58, 0xd8, 0x77, 0x82, 0x94, 0x5d, 0x0b, 0x1b, 0xd3, 0xe9, 0x77, 0x9c, 0x85, 0xfd, 0x4e, + 0x1a, 0x8e, 0xd1, 0x8e, 0xfb, 0xb7, 0x4c, 0x6f, 0x83, 0x74, 0x15, 0x40, 0xb6, 0xa5, 0x29, 0x77, + 0xcb, 0x0e, 0x54, 0x6c, 0x4b, 0xbb, 0x1e, 0x70, 0x90, 0x0a, 0xa0, 0xa6, 0xed, 0x84, 0x1b, 0xc8, + 0xdc, 0x71, 0x03, 0x4d, 0xdb, 0xb9, 0x1e, 0xe5, 0x81, 0xb3, 0x89, 0xf4, 0xe3, 0xb7, 0x52, 0x50, + 0x8d, 0x12, 0x33, 0xd7, 0x07, 0x15, 0xa6, 0x02, 0x5b, 0xfb, 0xb0, 0x4a, 0xdc, 0x7f, 0xd0, 0x06, + 0x37, 0xb4, 0x04, 0x8f, 0x58, 0xf8, 0x07, 0x5f, 0x84, 0x5f, 0x10, 0x0e, 0xc2, 0xd5, 0xe7, 0xfe, + 0xad, 0xc1, 0x3b, 0x64, 0xe9, 0xfd, 0x62, 0x9f, 0x31, 0xfe, 0xe1, 0xef, 0x32, 0xfe, 0x34, 0x05, + 0x33, 0x03, 0xfa, 0xf4, 0x77, 0xd9, 0xbd, 0xfe, 0xbd, 0x81, 0x4a, 0x71, 0xb7, 0xb6, 0x34, 0x17, + 0xf8, 0x32, 0x09, 0x5e, 0x90, 0xf3, 0x6d, 0x46, 0x23, 0x3f, 0x88, 0xf5, 0x2c, 0xdc, 0x13, 0xc9, + 0xc5, 0xfb, 0x74, 0x1e, 0xb2, 0x3b, 0xba, 0xed, 0xb8, 0x6f, 0x89, 0x87, 0xba, 0x13, 0xe2, 0xa2, + 0xb4, 0x12, 0x82, 0x0a, 0x85, 0x5c, 0x33, 0xcd, 0x36, 0x6f, 0x5e, 0x5a, 0x80, 0x71, 0x5f, 0x1d, + 0x07, 0x9f, 0x83, 0x6c, 0xd7, 0x34, 0xdb, 0x1c, 0x7c, 0x32, 0x0c, 0x4e, 0x68, 0xf9, 0x30, 0x29, + 0x9d, 0x34, 0x09, 0x88, 0x81, 0xb0, 0xef, 0x17, 0x70, 0xe8, 0x3d, 0x98, 0x08, 0xd4, 0xba, 0xef, + 0x9c, 0xe4, 0x02, 0x5f, 0xbe, 0xe9, 0xbb, 0x0a, 0xc0, 0xe8, 0xdd, 0x57, 0x69, 0x59, 0x16, 0xf9, + 0x50, 0xba, 0x7a, 0xfe, 0x8f, 0x47, 0xc4, 0x3b, 0x78, 0x0a, 0x80, 0x2f, 0xc9, 0x7b, 0x2a, 0xdc, + 0x56, 0x74, 0x86, 0xa0, 0x7a, 0x3a, 0x96, 0x8e, 0x07, 0x9d, 0x43, 0xe8, 0x27, 0xfc, 0x17, 0xb4, + 0x1e, 0x38, 0x98, 0x4f, 0xc0, 0x9f, 0x8a, 0x23, 0x73, 0xd1, 0xff, 0x3e, 0x4c, 0x46, 0x6d, 0x2e, + 0xd1, 0x23, 0x07, 0x23, 0xf4, 0x07, 0x15, 0xd5, 0x77, 0x1d, 0x82, 0xc3, 0x6d, 0xfe, 0xd5, 0x14, + 0xdc, 0x77, 0xe0, 0xfe, 0x0a, 0x3d, 0x71, 0x30, 0xec, 0x01, 0x61, 0x4e, 0xb5, 0x7e, 0x27, 0xac, + 0x6e, 0xd7, 0x94, 0xc0, 0x4d, 0x81, 0x68, 0x89, 0xf6, 0x6d, 0x00, 0x06, 0x4c, 0x6c, 0x7f, 0xe8, + 0x27, 0x0d, 0xa1, 0x97, 0xa3, 0x4f, 0xcc, 0xcf, 0x45, 0x22, 0x0c, 0xde, 0x73, 0x54, 0x1f, 0x49, + 0xce, 0xe0, 0x9f, 0xf6, 0xa8, 0xd0, 0x76, 0xc0, 0xb4, 0x1f, 0x10, 0xb1, 0x0f, 0x98, 0xf6, 0x83, + 0xe2, 0x66, 0x3e, 0xed, 0x07, 0x06, 0x7d, 0x03, 0xa6, 0x3d, 0x49, 0x74, 0x3b, 0x60, 0xda, 0x13, + 0xc5, 0x98, 0xd2, 0x10, 0xda, 0x81, 0xd1, 0x40, 0xb8, 0x81, 0xce, 0x44, 0xc2, 0x45, 0x45, 0x7e, + 0xd5, 0xb3, 0x49, 0x48, 0xfd, 0xf3, 0x1f, 0xe1, 0x7d, 0x07, 0xcc, 0xff, 0xe0, 0x90, 0xa2, 0xfa, + 0x48, 0x72, 0x06, 0xb7, 0xed, 0x5b, 0xee, 0x21, 0x8e, 0x8f, 0x00, 0xcd, 0x25, 0x44, 0x12, 0x2d, + 0x9f, 0x4b, 0x4c, 0xef, 0x36, 0x7c, 0xa3, 0xef, 0x1e, 0x77, 0xb4, 0xd0, 0x22, 0x7d, 0x59, 0xf5, + 0xc1, 0x44, 0xb4, 0x6e, 0x63, 0xab, 0xfc, 0x84, 0xe2, 0x78, 0x24, 0x9b, 0xcf, 0x4b, 0x55, 0x4f, + 0x1c, 0x40, 0xe1, 0xc2, 0xad, 0xbb, 0x47, 0x8e, 0x52, 0x34, 0xb9, 0xdf, 0x3b, 0x55, 0x4f, 0x1e, + 0x48, 0x23, 0x40, 0xef, 0xf6, 0x21, 0xc2, 0xff, 0x0f, 0x00, 0x00, 0xff, 0xff, 0x88, 0x17, 0x60, + 0x8b, 0xf1, 0x92, 0x00, 0x00, + } + r := bytes.NewReader(gzipped) + gzipr, err := compress_gzip.NewReader(r) + if err != nil { + panic(err) + } + ungzipped, err := io_ioutil.ReadAll(gzipr) + if err != nil { + panic(err) + } + if err := github_com_gogo_protobuf_proto.Unmarshal(ungzipped, d); err != nil { + panic(err) + } + return d } - func (this *MsgCreateValidator) Equal(that interface{}) bool { if that == nil { return this == nil @@ -1966,6 +2775,119 @@ func (this *Params) Equal(that interface{}) bool { } return true } +func (this *DelegationResponse) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*DelegationResponse) + if !ok { + that2, ok := that.(DelegationResponse) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if !this.Delegation.Equal(&that1.Delegation) { + return false + } + if !this.Balance.Equal(&that1.Balance) { + return false + } + return true +} +func (this *RedelegationEntryResponse) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*RedelegationEntryResponse) + if !ok { + that2, ok := that.(RedelegationEntryResponse) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if !this.RedelegationEntry.Equal(&that1.RedelegationEntry) { + return false + } + if !this.Balance.Equal(that1.Balance) { + return false + } + return true +} +func (this *RedelegationResponse) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*RedelegationResponse) + if !ok { + that2, ok := that.(RedelegationResponse) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if !this.Redelegation.Equal(&that1.Redelegation) { + return false + } + if len(this.Entries) != len(that1.Entries) { + return false + } + for i := range this.Entries { + if !this.Entries[i].Equal(&that1.Entries[i]) { + return false + } + } + return true +} +func (this *Pool) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*Pool) + if !ok { + that2, ok := that.(Pool) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if !this.NotBondedTokens.Equal(that1.NotBondedTokens) { + return false + } + if !this.BondedTokens.Equal(that1.BondedTokens) { + return false + } + return true +} func (m *MsgCreateValidator) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -3052,40 +3974,216 @@ func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func encodeVarintStaking(dAtA []byte, offset int, v uint64) int { - offset -= sovStaking(v) - base := offset - for v >= 1<<7 { - dAtA[offset] = uint8(v&0x7f | 0x80) - v >>= 7 - offset++ +func (m *DelegationResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - dAtA[offset] = uint8(v) - return base + return dAtA[:n], nil } -func (m *MsgCreateValidator) Size() (n int) { - if m == nil { - return 0 - } + +func (m *DelegationResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DelegationResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - l = m.Description.Size() - n += 1 + l + sovStaking(uint64(l)) - l = m.Commission.Size() - n += 1 + l + sovStaking(uint64(l)) - l = m.MinSelfDelegation.Size() - n += 1 + l + sovStaking(uint64(l)) - l = len(m.DelegatorAddress) - if l > 0 { - n += 1 + l + sovStaking(uint64(l)) - } - l = len(m.ValidatorAddress) - if l > 0 { - n += 1 + l + sovStaking(uint64(l)) + { + size, err := m.Balance.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStaking(dAtA, i, uint64(size)) } - l = len(m.Pubkey) - if l > 0 { - n += 1 + l + sovStaking(uint64(l)) + i-- + dAtA[i] = 0x12 + { + size, err := m.Delegation.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStaking(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *RedelegationEntryResponse) 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 *RedelegationEntryResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RedelegationEntryResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size := m.Balance.Size() + i -= size + if _, err := m.Balance.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintStaking(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + { + size, err := m.RedelegationEntry.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStaking(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *RedelegationResponse) 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 *RedelegationResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RedelegationResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Entries) > 0 { + for iNdEx := len(m.Entries) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Entries[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStaking(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + { + size, err := m.Redelegation.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintStaking(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *Pool) 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 *Pool) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Pool) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size := m.BondedTokens.Size() + i -= size + if _, err := m.BondedTokens.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintStaking(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + { + size := m.NotBondedTokens.Size() + i -= size + if _, err := m.NotBondedTokens.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintStaking(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func encodeVarintStaking(dAtA []byte, offset int, v uint64) int { + offset -= sovStaking(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *MsgCreateValidator) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Description.Size() + n += 1 + l + sovStaking(uint64(l)) + l = m.Commission.Size() + n += 1 + l + sovStaking(uint64(l)) + l = m.MinSelfDelegation.Size() + n += 1 + l + sovStaking(uint64(l)) + l = len(m.DelegatorAddress) + if l > 0 { + n += 1 + l + sovStaking(uint64(l)) + } + l = len(m.ValidatorAddress) + if l > 0 { + n += 1 + l + sovStaking(uint64(l)) + } + l = len(m.Pubkey) + if l > 0 { + n += 1 + l + sovStaking(uint64(l)) } l = m.Value.Size() n += 1 + l + sovStaking(uint64(l)) @@ -3485,6 +4583,62 @@ func (m *Params) Size() (n int) { return n } +func (m *DelegationResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Delegation.Size() + n += 1 + l + sovStaking(uint64(l)) + l = m.Balance.Size() + n += 1 + l + sovStaking(uint64(l)) + return n +} + +func (m *RedelegationEntryResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.RedelegationEntry.Size() + n += 1 + l + sovStaking(uint64(l)) + l = m.Balance.Size() + n += 1 + l + sovStaking(uint64(l)) + return n +} + +func (m *RedelegationResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Redelegation.Size() + n += 1 + l + sovStaking(uint64(l)) + if len(m.Entries) > 0 { + for _, e := range m.Entries { + l = e.Size() + n += 1 + l + sovStaking(uint64(l)) + } + } + return n +} + +func (m *Pool) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.NotBondedTokens.Size() + n += 1 + l + sovStaking(uint64(l)) + l = m.BondedTokens.Size() + n += 1 + l + sovStaking(uint64(l)) + return n +} + func sovStaking(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } @@ -6920,6 +8074,486 @@ func (m *Params) Unmarshal(dAtA []byte) error { } return nil } +func (m *DelegationResponse) 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 ErrIntOverflowStaking + } + 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: DelegationResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DelegationResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Delegation", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStaking + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Delegation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Balance", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStaking + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Balance.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStaking(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthStaking + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthStaking + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RedelegationEntryResponse) 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 ErrIntOverflowStaking + } + 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: RedelegationEntryResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RedelegationEntryResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RedelegationEntry", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStaking + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.RedelegationEntry.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Balance", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + 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 ErrInvalidLengthStaking + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Balance.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStaking(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthStaking + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthStaking + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RedelegationResponse) 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 ErrIntOverflowStaking + } + 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: RedelegationResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RedelegationResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Redelegation", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStaking + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Redelegation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthStaking + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Entries = append(m.Entries, RedelegationEntryResponse{}) + if err := m.Entries[len(m.Entries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStaking(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthStaking + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthStaking + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Pool) 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 ErrIntOverflowStaking + } + 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: Pool: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Pool: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NotBondedTokens", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + 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 ErrInvalidLengthStaking + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.NotBondedTokens.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BondedTokens", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowStaking + } + 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 ErrInvalidLengthStaking + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthStaking + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.BondedTokens.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipStaking(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthStaking + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthStaking + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func skipStaking(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0