From c98739039ba2364a2bac39f8bdd728b0cead5055 Mon Sep 17 00:00:00 2001 From: Facundo Medica Date: Mon, 28 Nov 2022 11:41:28 -0300 Subject: [PATCH 1/8] feat: (x/bank) add spendable balances cmd --- x/bank/client/cli/query.go | 51 +++++++++++++++++++++++++ x/bank/client/cli/query_test.go | 67 +++++++++++++++++++++++++++++++++ 2 files changed, 118 insertions(+) diff --git a/x/bank/client/cli/query.go b/x/bank/client/cli/query.go index df544fd315d6..ae87d482ac59 100644 --- a/x/bank/client/cli/query.go +++ b/x/bank/client/cli/query.go @@ -108,6 +108,57 @@ Example: return cmd } +func GetSpendableBalancesCmd() *cobra.Command { + cmd := &cobra.Command{ + Use: "spendable-balances [address]", + Short: "Query for account spendable balances by address", + Long: strings.TrimSpace( + fmt.Sprintf(`Query the spendable balances of an account. + +Example: + $ %s query %s spendable-balances [address] +`, + version.AppName, types.ModuleName, + ), + ), + Args: cobra.ExactArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + clientCtx, err := client.GetClientQueryContext(cmd) + if err != nil { + return err + } + + queryClient := types.NewQueryClient(clientCtx) + + addr, err := sdk.AccAddressFromBech32(args[0]) + if err != nil { + return err + } + + pageReq, err := client.ReadPageRequest(cmd.Flags()) + if err != nil { + return err + } + + ctx := cmd.Context() + params := types.NewQuerySpendableBalancesRequest(addr, pageReq) + + res, err := queryClient.SpendableBalances(ctx, params) + if err != nil { + return err + } + + return clientCtx.PrintProto(res) + + }, + } + + flags.AddQueryFlagsToCmd(cmd) + flags.AddPaginationFlagsToCmd(cmd, "spendable balances") + + return cmd +} + // GetCmdDenomsMetadata defines the cobra command to query client denomination metadata. func GetCmdDenomsMetadata() *cobra.Command { cmd := &cobra.Command{ diff --git a/x/bank/client/cli/query_test.go b/x/bank/client/cli/query_test.go index 243513c60611..a4e2440eca38 100644 --- a/x/bank/client/cli/query_test.go +++ b/x/bank/client/cli/query_test.go @@ -120,6 +120,73 @@ func (s *CLITestSuite) TestGetBalancesCmd() { } } +func (s *CLITestSuite) TestGetSpendableBalancesCmd() { + accounts := testutil.CreateKeyringAccounts(s.T(), s.kr, 1) + + cmd := cli.GetSpendableBalancesCmd() + cmd.SetOutput(io.Discard) + + testCases := []struct { + name string + ctxGen func() client.Context + args []string + expectResult proto.Message + expectErr bool + }{ + { + "valid query", + func() client.Context { + bz, _ := s.encCfg.Codec.Marshal(&types.QuerySpendableBalancesResponse{}) + c := clitestutil.NewMockTendermintRPC(abci.ResponseQuery{ + Value: bz, + }) + return s.baseCtx.WithClient(c) + }, + []string{ + accounts[0].Address.String(), + fmt.Sprintf("--%s=json", flags.FlagOutput), + }, + &types.QuerySpendableBalancesResponse{}, + false, + }, + { + "invalid Address", + func() client.Context { + return s.baseCtx + }, + []string{ + "foo", + }, + nil, + true, + }, + } + + for _, tc := range testCases { + tc := tc + + s.Run(tc.name, func() { + var outBuf bytes.Buffer + + clientCtx := tc.ctxGen().WithOutput(&outBuf) + ctx := svrcmd.CreateExecuteContext(context.Background()) + + cmd.SetContext(ctx) + cmd.SetArgs(tc.args) + + s.Require().NoError(client.SetCmdClientContextHandler(clientCtx, cmd)) + + err := cmd.Execute() + if tc.expectErr { + s.Require().Error(err) + } else { + s.Require().NoError(s.encCfg.Codec.UnmarshalJSON(outBuf.Bytes(), tc.expectResult)) + s.Require().NoError(err) + } + }) + } +} + func (s *CLITestSuite) TestGetCmdDenomsMetadata() { cmd := cli.GetCmdDenomsMetadata() cmd.SetOutput(io.Discard) From c1c3dd3713b628a6e3ceb6dc76eabdfab4d017b7 Mon Sep 17 00:00:00 2001 From: Facundo Medica Date: Mon, 28 Nov 2022 11:43:24 -0300 Subject: [PATCH 2/8] cl++ --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 3c58fdbd8d8c..1436023e3634 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -39,6 +39,7 @@ Ref: https://keepachangelog.com/en/1.0.0/ ### Features +* (x/bank) [#14045](https://github.com/cosmos/cosmos-sdk/pull/14045) Add CLI command `spendable-balances`. * (x/evidence) [#13740](https://github.com/cosmos/cosmos-sdk/pull/13740) Add new proto field `hash` of type `string` to `QueryEvidenceRequest` which helps to decode the hash properly while using query API. * (core) [#13306](https://github.com/cosmos/cosmos-sdk/pull/13306) Add a `FormatCoins` function to in `core/coins` to format sdk Coins following the Value Renderers spec. * (math) [#13306](https://github.com/cosmos/cosmos-sdk/pull/13306) Add `FormatInt` and `FormatDec` functiosn in `math` to format integers and decimals following the Value Renderers spec. From 7f37972136534875522452494d334f2a2f627c9a Mon Sep 17 00:00:00 2001 From: Facundo Medica Date: Mon, 28 Nov 2022 11:48:03 -0300 Subject: [PATCH 3/8] lint --- x/bank/client/cli/query.go | 1 - 1 file changed, 1 deletion(-) diff --git a/x/bank/client/cli/query.go b/x/bank/client/cli/query.go index ae87d482ac59..892c3a608b20 100644 --- a/x/bank/client/cli/query.go +++ b/x/bank/client/cli/query.go @@ -149,7 +149,6 @@ Example: } return clientCtx.PrintProto(res) - }, } From 523419437eadee838a8e7c9eba29d7d4c3ebc48f Mon Sep 17 00:00:00 2001 From: Facundo Medica Date: Tue, 29 Nov 2022 15:20:16 -0300 Subject: [PATCH 4/8] fix from Likhita --- x/bank/client/cli/query.go | 1 + 1 file changed, 1 insertion(+) diff --git a/x/bank/client/cli/query.go b/x/bank/client/cli/query.go index 892c3a608b20..e3f0045e0e56 100644 --- a/x/bank/client/cli/query.go +++ b/x/bank/client/cli/query.go @@ -31,6 +31,7 @@ func GetQueryCmd() *cobra.Command { cmd.AddCommand( GetBalancesCmd(), + GetSpendableBalancesCmd(), GetCmdQueryTotalSupply(), GetCmdDenomsMetadata(), GetCmdQuerySendEnabled(), From f204a1343a78ae46d75ee67cd34996064ebb4b68 Mon Sep 17 00:00:00 2001 From: Facundo Medica Date: Tue, 20 Dec 2022 11:07:15 -0300 Subject: [PATCH 5/8] finish spendable-balances command --- CHANGELOG.md | 2 +- api/cosmos/bank/v1beta1/query.pulsar.go | 1754 +++++++++++++++++----- api/cosmos/bank/v1beta1/query_grpc.pb.go | 54 +- proto/cosmos/bank/v1beta1/query.proto | 39 +- x/bank/client/cli/query.go | 38 +- x/bank/client/cli/query_test.go | 17 + x/bank/keeper/grpc_query.go | 31 +- x/bank/keeper/grpc_query_test.go | 52 + x/bank/types/querier.go | 8 + x/bank/types/query.pb.go | 627 ++++++-- x/bank/types/query.pb.gw.go | 119 ++ x/gov/testutil/expected_keepers_mocks.go | 15 + 12 files changed, 2297 insertions(+), 459 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 4f11e0b0a34d..e1d060a87d87 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -39,7 +39,7 @@ Ref: https://keepachangelog.com/en/1.0.0/ ### Features -* (x/bank) [#14045](https://github.com/cosmos/cosmos-sdk/pull/14045) Add CLI command `spendable-balances`. +* (x/bank) [#14045](https://github.com/cosmos/cosmos-sdk/pull/14045) Add CLI command `spendable-balances`, which also accepts the flag `--denom`. * (x/slashing, x/staking) [#14363](https://github.com/cosmos/cosmos-sdk/pull/14363) Add the infraction a validator commited type as an argument to a `SlashWithInfractionReason` keeper method. * (x/evidence) [#13740](https://github.com/cosmos/cosmos-sdk/pull/13740) Add new proto field `hash` of type `string` to `QueryEvidenceRequest` which helps to decode the hash properly while using query API. * (core) [#13306](https://github.com/cosmos/cosmos-sdk/pull/13306) Add a `FormatCoins` function to in `core/coins` to format sdk Coins following the Value Renderers spec. diff --git a/api/cosmos/bank/v1beta1/query.pulsar.go b/api/cosmos/bank/v1beta1/query.pulsar.go index bfd36bd11895..ae6bebdff958 100644 --- a/api/cosmos/bank/v1beta1/query.pulsar.go +++ b/api/cosmos/bank/v1beta1/query.pulsar.go @@ -3082,6 +3082,925 @@ func (x *fastReflection_QuerySpendableBalancesResponse) ProtoMethods() *protoifa } } +var ( + md_QuerySpendableBalanceByDenomRequest protoreflect.MessageDescriptor + fd_QuerySpendableBalanceByDenomRequest_address protoreflect.FieldDescriptor + fd_QuerySpendableBalanceByDenomRequest_denom protoreflect.FieldDescriptor +) + +func init() { + file_cosmos_bank_v1beta1_query_proto_init() + md_QuerySpendableBalanceByDenomRequest = File_cosmos_bank_v1beta1_query_proto.Messages().ByName("QuerySpendableBalanceByDenomRequest") + fd_QuerySpendableBalanceByDenomRequest_address = md_QuerySpendableBalanceByDenomRequest.Fields().ByName("address") + fd_QuerySpendableBalanceByDenomRequest_denom = md_QuerySpendableBalanceByDenomRequest.Fields().ByName("denom") +} + +var _ protoreflect.Message = (*fastReflection_QuerySpendableBalanceByDenomRequest)(nil) + +type fastReflection_QuerySpendableBalanceByDenomRequest QuerySpendableBalanceByDenomRequest + +func (x *QuerySpendableBalanceByDenomRequest) ProtoReflect() protoreflect.Message { + return (*fastReflection_QuerySpendableBalanceByDenomRequest)(x) +} + +func (x *QuerySpendableBalanceByDenomRequest) slowProtoReflect() protoreflect.Message { + mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[6] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_QuerySpendableBalanceByDenomRequest_messageType fastReflection_QuerySpendableBalanceByDenomRequest_messageType +var _ protoreflect.MessageType = fastReflection_QuerySpendableBalanceByDenomRequest_messageType{} + +type fastReflection_QuerySpendableBalanceByDenomRequest_messageType struct{} + +func (x fastReflection_QuerySpendableBalanceByDenomRequest_messageType) Zero() protoreflect.Message { + return (*fastReflection_QuerySpendableBalanceByDenomRequest)(nil) +} +func (x fastReflection_QuerySpendableBalanceByDenomRequest_messageType) New() protoreflect.Message { + return new(fastReflection_QuerySpendableBalanceByDenomRequest) +} +func (x fastReflection_QuerySpendableBalanceByDenomRequest_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QuerySpendableBalanceByDenomRequest +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QuerySpendableBalanceByDenomRequest) Descriptor() protoreflect.MessageDescriptor { + return md_QuerySpendableBalanceByDenomRequest +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_QuerySpendableBalanceByDenomRequest) Type() protoreflect.MessageType { + return _fastReflection_QuerySpendableBalanceByDenomRequest_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QuerySpendableBalanceByDenomRequest) New() protoreflect.Message { + return new(fastReflection_QuerySpendableBalanceByDenomRequest) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QuerySpendableBalanceByDenomRequest) Interface() protoreflect.ProtoMessage { + return (*QuerySpendableBalanceByDenomRequest)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_QuerySpendableBalanceByDenomRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Address != "" { + value := protoreflect.ValueOfString(x.Address) + if !f(fd_QuerySpendableBalanceByDenomRequest_address, value) { + return + } + } + if x.Denom != "" { + value := protoreflect.ValueOfString(x.Denom) + if !f(fd_QuerySpendableBalanceByDenomRequest_denom, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_QuerySpendableBalanceByDenomRequest) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "cosmos.bank.v1beta1.QuerySpendableBalanceByDenomRequest.address": + return x.Address != "" + case "cosmos.bank.v1beta1.QuerySpendableBalanceByDenomRequest.denom": + return x.Denom != "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.bank.v1beta1.QuerySpendableBalanceByDenomRequest")) + } + panic(fmt.Errorf("message cosmos.bank.v1beta1.QuerySpendableBalanceByDenomRequest does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QuerySpendableBalanceByDenomRequest) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "cosmos.bank.v1beta1.QuerySpendableBalanceByDenomRequest.address": + x.Address = "" + case "cosmos.bank.v1beta1.QuerySpendableBalanceByDenomRequest.denom": + x.Denom = "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.bank.v1beta1.QuerySpendableBalanceByDenomRequest")) + } + panic(fmt.Errorf("message cosmos.bank.v1beta1.QuerySpendableBalanceByDenomRequest does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_QuerySpendableBalanceByDenomRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "cosmos.bank.v1beta1.QuerySpendableBalanceByDenomRequest.address": + value := x.Address + return protoreflect.ValueOfString(value) + case "cosmos.bank.v1beta1.QuerySpendableBalanceByDenomRequest.denom": + value := x.Denom + return protoreflect.ValueOfString(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.bank.v1beta1.QuerySpendableBalanceByDenomRequest")) + } + panic(fmt.Errorf("message cosmos.bank.v1beta1.QuerySpendableBalanceByDenomRequest does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QuerySpendableBalanceByDenomRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "cosmos.bank.v1beta1.QuerySpendableBalanceByDenomRequest.address": + x.Address = value.Interface().(string) + case "cosmos.bank.v1beta1.QuerySpendableBalanceByDenomRequest.denom": + x.Denom = value.Interface().(string) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.bank.v1beta1.QuerySpendableBalanceByDenomRequest")) + } + panic(fmt.Errorf("message cosmos.bank.v1beta1.QuerySpendableBalanceByDenomRequest does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QuerySpendableBalanceByDenomRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.bank.v1beta1.QuerySpendableBalanceByDenomRequest.address": + panic(fmt.Errorf("field address of message cosmos.bank.v1beta1.QuerySpendableBalanceByDenomRequest is not mutable")) + case "cosmos.bank.v1beta1.QuerySpendableBalanceByDenomRequest.denom": + panic(fmt.Errorf("field denom of message cosmos.bank.v1beta1.QuerySpendableBalanceByDenomRequest is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.bank.v1beta1.QuerySpendableBalanceByDenomRequest")) + } + panic(fmt.Errorf("message cosmos.bank.v1beta1.QuerySpendableBalanceByDenomRequest does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_QuerySpendableBalanceByDenomRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.bank.v1beta1.QuerySpendableBalanceByDenomRequest.address": + return protoreflect.ValueOfString("") + case "cosmos.bank.v1beta1.QuerySpendableBalanceByDenomRequest.denom": + return protoreflect.ValueOfString("") + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.bank.v1beta1.QuerySpendableBalanceByDenomRequest")) + } + panic(fmt.Errorf("message cosmos.bank.v1beta1.QuerySpendableBalanceByDenomRequest does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_QuerySpendableBalanceByDenomRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in cosmos.bank.v1beta1.QuerySpendableBalanceByDenomRequest", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_QuerySpendableBalanceByDenomRequest) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QuerySpendableBalanceByDenomRequest) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_QuerySpendableBalanceByDenomRequest) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_QuerySpendableBalanceByDenomRequest) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QuerySpendableBalanceByDenomRequest) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + l = len(x.Address) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Denom) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*QuerySpendableBalanceByDenomRequest) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if len(x.Denom) > 0 { + i -= len(x.Denom) + copy(dAtA[i:], x.Denom) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Denom))) + i-- + dAtA[i] = 0x12 + } + if len(x.Address) > 0 { + i -= len(x.Address) + copy(dAtA[i:], x.Address) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Address))) + i-- + dAtA[i] = 0xa + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*QuerySpendableBalanceByDenomRequest) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QuerySpendableBalanceByDenomRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QuerySpendableBalanceByDenomRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Address = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Denom = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_QuerySpendableBalanceByDenomResponse protoreflect.MessageDescriptor + fd_QuerySpendableBalanceByDenomResponse_balance protoreflect.FieldDescriptor +) + +func init() { + file_cosmos_bank_v1beta1_query_proto_init() + md_QuerySpendableBalanceByDenomResponse = File_cosmos_bank_v1beta1_query_proto.Messages().ByName("QuerySpendableBalanceByDenomResponse") + fd_QuerySpendableBalanceByDenomResponse_balance = md_QuerySpendableBalanceByDenomResponse.Fields().ByName("balance") +} + +var _ protoreflect.Message = (*fastReflection_QuerySpendableBalanceByDenomResponse)(nil) + +type fastReflection_QuerySpendableBalanceByDenomResponse QuerySpendableBalanceByDenomResponse + +func (x *QuerySpendableBalanceByDenomResponse) ProtoReflect() protoreflect.Message { + return (*fastReflection_QuerySpendableBalanceByDenomResponse)(x) +} + +func (x *QuerySpendableBalanceByDenomResponse) slowProtoReflect() protoreflect.Message { + mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_QuerySpendableBalanceByDenomResponse_messageType fastReflection_QuerySpendableBalanceByDenomResponse_messageType +var _ protoreflect.MessageType = fastReflection_QuerySpendableBalanceByDenomResponse_messageType{} + +type fastReflection_QuerySpendableBalanceByDenomResponse_messageType struct{} + +func (x fastReflection_QuerySpendableBalanceByDenomResponse_messageType) Zero() protoreflect.Message { + return (*fastReflection_QuerySpendableBalanceByDenomResponse)(nil) +} +func (x fastReflection_QuerySpendableBalanceByDenomResponse_messageType) New() protoreflect.Message { + return new(fastReflection_QuerySpendableBalanceByDenomResponse) +} +func (x fastReflection_QuerySpendableBalanceByDenomResponse_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QuerySpendableBalanceByDenomResponse +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QuerySpendableBalanceByDenomResponse) Descriptor() protoreflect.MessageDescriptor { + return md_QuerySpendableBalanceByDenomResponse +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_QuerySpendableBalanceByDenomResponse) Type() protoreflect.MessageType { + return _fastReflection_QuerySpendableBalanceByDenomResponse_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QuerySpendableBalanceByDenomResponse) New() protoreflect.Message { + return new(fastReflection_QuerySpendableBalanceByDenomResponse) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QuerySpendableBalanceByDenomResponse) Interface() protoreflect.ProtoMessage { + return (*QuerySpendableBalanceByDenomResponse)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_QuerySpendableBalanceByDenomResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Balance != nil { + value := protoreflect.ValueOfMessage(x.Balance.ProtoReflect()) + if !f(fd_QuerySpendableBalanceByDenomResponse_balance, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_QuerySpendableBalanceByDenomResponse) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "cosmos.bank.v1beta1.QuerySpendableBalanceByDenomResponse.balance": + return x.Balance != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.bank.v1beta1.QuerySpendableBalanceByDenomResponse")) + } + panic(fmt.Errorf("message cosmos.bank.v1beta1.QuerySpendableBalanceByDenomResponse does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QuerySpendableBalanceByDenomResponse) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "cosmos.bank.v1beta1.QuerySpendableBalanceByDenomResponse.balance": + x.Balance = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.bank.v1beta1.QuerySpendableBalanceByDenomResponse")) + } + panic(fmt.Errorf("message cosmos.bank.v1beta1.QuerySpendableBalanceByDenomResponse does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_QuerySpendableBalanceByDenomResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "cosmos.bank.v1beta1.QuerySpendableBalanceByDenomResponse.balance": + value := x.Balance + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.bank.v1beta1.QuerySpendableBalanceByDenomResponse")) + } + panic(fmt.Errorf("message cosmos.bank.v1beta1.QuerySpendableBalanceByDenomResponse does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QuerySpendableBalanceByDenomResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "cosmos.bank.v1beta1.QuerySpendableBalanceByDenomResponse.balance": + x.Balance = value.Message().Interface().(*v1beta1.Coin) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.bank.v1beta1.QuerySpendableBalanceByDenomResponse")) + } + panic(fmt.Errorf("message cosmos.bank.v1beta1.QuerySpendableBalanceByDenomResponse does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QuerySpendableBalanceByDenomResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.bank.v1beta1.QuerySpendableBalanceByDenomResponse.balance": + if x.Balance == nil { + x.Balance = new(v1beta1.Coin) + } + return protoreflect.ValueOfMessage(x.Balance.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.bank.v1beta1.QuerySpendableBalanceByDenomResponse")) + } + panic(fmt.Errorf("message cosmos.bank.v1beta1.QuerySpendableBalanceByDenomResponse does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_QuerySpendableBalanceByDenomResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.bank.v1beta1.QuerySpendableBalanceByDenomResponse.balance": + m := new(v1beta1.Coin) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.bank.v1beta1.QuerySpendableBalanceByDenomResponse")) + } + panic(fmt.Errorf("message cosmos.bank.v1beta1.QuerySpendableBalanceByDenomResponse does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_QuerySpendableBalanceByDenomResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in cosmos.bank.v1beta1.QuerySpendableBalanceByDenomResponse", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_QuerySpendableBalanceByDenomResponse) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QuerySpendableBalanceByDenomResponse) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_QuerySpendableBalanceByDenomResponse) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_QuerySpendableBalanceByDenomResponse) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QuerySpendableBalanceByDenomResponse) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + if x.Balance != nil { + l = options.Size(x.Balance) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*QuerySpendableBalanceByDenomResponse) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if x.Balance != nil { + encoded, err := options.Marshal(x.Balance) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0xa + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*QuerySpendableBalanceByDenomResponse) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QuerySpendableBalanceByDenomResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QuerySpendableBalanceByDenomResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Balance", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.Balance == nil { + x.Balance = &v1beta1.Coin{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Balance); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + var ( md_QueryTotalSupplyRequest protoreflect.MessageDescriptor fd_QueryTotalSupplyRequest_pagination protoreflect.FieldDescriptor @@ -3102,7 +4021,7 @@ func (x *QueryTotalSupplyRequest) ProtoReflect() protoreflect.Message { } func (x *QueryTotalSupplyRequest) slowProtoReflect() protoreflect.Message { - mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[6] + mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[8] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3590,7 +4509,7 @@ func (x *QueryTotalSupplyResponse) ProtoReflect() protoreflect.Message { } func (x *QueryTotalSupplyResponse) slowProtoReflect() protoreflect.Message { - mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[7] + mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[9] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4110,7 +5029,7 @@ func (x *QuerySupplyOfRequest) ProtoReflect() protoreflect.Message { } func (x *QuerySupplyOfRequest) slowProtoReflect() protoreflect.Message { - mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[8] + mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[10] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4530,7 +5449,7 @@ func (x *QuerySupplyOfResponse) ProtoReflect() protoreflect.Message { } func (x *QuerySupplyOfResponse) slowProtoReflect() protoreflect.Message { - mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[9] + mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[11] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4963,7 +5882,7 @@ func (x *QueryParamsRequest) ProtoReflect() protoreflect.Message { } func (x *QueryParamsRequest) slowProtoReflect() protoreflect.Message { - mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[10] + mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[12] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5321,7 +6240,7 @@ func (x *QueryParamsResponse) ProtoReflect() protoreflect.Message { } func (x *QueryParamsResponse) slowProtoReflect() protoreflect.Message { - mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[11] + mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[13] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5756,7 +6675,7 @@ func (x *QueryDenomsMetadataRequest) ProtoReflect() protoreflect.Message { } func (x *QueryDenomsMetadataRequest) slowProtoReflect() protoreflect.Message { - mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[12] + mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[14] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6244,7 +7163,7 @@ func (x *QueryDenomsMetadataResponse) ProtoReflect() protoreflect.Message { } func (x *QueryDenomsMetadataResponse) slowProtoReflect() protoreflect.Message { - mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[13] + mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[15] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6764,7 +7683,7 @@ func (x *QueryDenomMetadataRequest) ProtoReflect() protoreflect.Message { } func (x *QueryDenomMetadataRequest) slowProtoReflect() protoreflect.Message { - mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[14] + mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[16] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7184,7 +8103,7 @@ func (x *QueryDenomMetadataResponse) ProtoReflect() protoreflect.Message { } func (x *QueryDenomMetadataResponse) slowProtoReflect() protoreflect.Message { - mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[15] + mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[17] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7621,7 +8540,7 @@ func (x *QueryDenomOwnersRequest) ProtoReflect() protoreflect.Message { } func (x *QueryDenomOwnersRequest) slowProtoReflect() protoreflect.Message { - mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[16] + mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[18] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8120,7 +9039,7 @@ func (x *DenomOwner) ProtoReflect() protoreflect.Message { } func (x *DenomOwner) slowProtoReflect() protoreflect.Message { - mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[17] + mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[19] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8670,7 +9589,7 @@ func (x *QueryDenomOwnersResponse) ProtoReflect() protoreflect.Message { } func (x *QueryDenomOwnersResponse) slowProtoReflect() protoreflect.Message { - mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[18] + mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[20] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9238,7 +10157,7 @@ func (x *QuerySendEnabledRequest) ProtoReflect() protoreflect.Message { } func (x *QuerySendEnabledRequest) slowProtoReflect() protoreflect.Message { - mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[19] + mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[21] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9804,7 +10723,7 @@ func (x *QuerySendEnabledResponse) ProtoReflect() protoreflect.Message { } func (x *QuerySendEnabledResponse) slowProtoReflect() protoreflect.Message { - mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[20] + mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[22] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -10593,6 +11512,95 @@ func (x *QuerySpendableBalancesResponse) GetPagination() *v1beta11.PageResponse return nil } +// QuerySpendableBalanceByDenomRequest defines the gRPC request structure for +// querying an account's spendable balance for a specific denom. +// +// Since: cosmos-sdk 0.47 +type QuerySpendableBalanceByDenomRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // address is the address to query balances for. + Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` + // denom is the coin denom to query balances for. + Denom string `protobuf:"bytes,2,opt,name=denom,proto3" json:"denom,omitempty"` +} + +func (x *QuerySpendableBalanceByDenomRequest) Reset() { + *x = QuerySpendableBalanceByDenomRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QuerySpendableBalanceByDenomRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QuerySpendableBalanceByDenomRequest) ProtoMessage() {} + +// Deprecated: Use QuerySpendableBalanceByDenomRequest.ProtoReflect.Descriptor instead. +func (*QuerySpendableBalanceByDenomRequest) Descriptor() ([]byte, []int) { + return file_cosmos_bank_v1beta1_query_proto_rawDescGZIP(), []int{6} +} + +func (x *QuerySpendableBalanceByDenomRequest) GetAddress() string { + if x != nil { + return x.Address + } + return "" +} + +func (x *QuerySpendableBalanceByDenomRequest) GetDenom() string { + if x != nil { + return x.Denom + } + return "" +} + +// QuerySpendableBalanceByDenomResponse defines the gRPC response structure for +// querying an account's spendable balance for a specific denom. +// +// Since: cosmos-sdk 0.47 +type QuerySpendableBalanceByDenomResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // balance is the balance of the coin. + Balance *v1beta1.Coin `protobuf:"bytes,1,opt,name=balance,proto3" json:"balance,omitempty"` +} + +func (x *QuerySpendableBalanceByDenomResponse) Reset() { + *x = QuerySpendableBalanceByDenomResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QuerySpendableBalanceByDenomResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QuerySpendableBalanceByDenomResponse) ProtoMessage() {} + +// Deprecated: Use QuerySpendableBalanceByDenomResponse.ProtoReflect.Descriptor instead. +func (*QuerySpendableBalanceByDenomResponse) Descriptor() ([]byte, []int) { + return file_cosmos_bank_v1beta1_query_proto_rawDescGZIP(), []int{7} +} + +func (x *QuerySpendableBalanceByDenomResponse) GetBalance() *v1beta1.Coin { + if x != nil { + return x.Balance + } + return nil +} + // QueryTotalSupplyRequest is the request type for the Query/TotalSupply RPC // method. type QueryTotalSupplyRequest struct { @@ -10609,7 +11617,7 @@ type QueryTotalSupplyRequest struct { func (x *QueryTotalSupplyRequest) Reset() { *x = QueryTotalSupplyRequest{} if protoimpl.UnsafeEnabled { - mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[6] + mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[8] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10623,7 +11631,7 @@ func (*QueryTotalSupplyRequest) ProtoMessage() {} // Deprecated: Use QueryTotalSupplyRequest.ProtoReflect.Descriptor instead. func (*QueryTotalSupplyRequest) Descriptor() ([]byte, []int) { - return file_cosmos_bank_v1beta1_query_proto_rawDescGZIP(), []int{6} + return file_cosmos_bank_v1beta1_query_proto_rawDescGZIP(), []int{8} } func (x *QueryTotalSupplyRequest) GetPagination() *v1beta11.PageRequest { @@ -10651,7 +11659,7 @@ type QueryTotalSupplyResponse struct { func (x *QueryTotalSupplyResponse) Reset() { *x = QueryTotalSupplyResponse{} if protoimpl.UnsafeEnabled { - mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[7] + mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[9] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10665,7 +11673,7 @@ func (*QueryTotalSupplyResponse) ProtoMessage() {} // Deprecated: Use QueryTotalSupplyResponse.ProtoReflect.Descriptor instead. func (*QueryTotalSupplyResponse) Descriptor() ([]byte, []int) { - return file_cosmos_bank_v1beta1_query_proto_rawDescGZIP(), []int{7} + return file_cosmos_bank_v1beta1_query_proto_rawDescGZIP(), []int{9} } func (x *QueryTotalSupplyResponse) GetSupply() []*v1beta1.Coin { @@ -10695,7 +11703,7 @@ type QuerySupplyOfRequest struct { func (x *QuerySupplyOfRequest) Reset() { *x = QuerySupplyOfRequest{} if protoimpl.UnsafeEnabled { - mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[8] + mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[10] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10709,7 +11717,7 @@ func (*QuerySupplyOfRequest) ProtoMessage() {} // Deprecated: Use QuerySupplyOfRequest.ProtoReflect.Descriptor instead. func (*QuerySupplyOfRequest) Descriptor() ([]byte, []int) { - return file_cosmos_bank_v1beta1_query_proto_rawDescGZIP(), []int{8} + return file_cosmos_bank_v1beta1_query_proto_rawDescGZIP(), []int{10} } func (x *QuerySupplyOfRequest) GetDenom() string { @@ -10732,7 +11740,7 @@ type QuerySupplyOfResponse struct { func (x *QuerySupplyOfResponse) Reset() { *x = QuerySupplyOfResponse{} if protoimpl.UnsafeEnabled { - mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[9] + mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[11] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10746,7 +11754,7 @@ func (*QuerySupplyOfResponse) ProtoMessage() {} // Deprecated: Use QuerySupplyOfResponse.ProtoReflect.Descriptor instead. func (*QuerySupplyOfResponse) Descriptor() ([]byte, []int) { - return file_cosmos_bank_v1beta1_query_proto_rawDescGZIP(), []int{9} + return file_cosmos_bank_v1beta1_query_proto_rawDescGZIP(), []int{11} } func (x *QuerySupplyOfResponse) GetAmount() *v1beta1.Coin { @@ -10766,7 +11774,7 @@ type QueryParamsRequest struct { func (x *QueryParamsRequest) Reset() { *x = QueryParamsRequest{} if protoimpl.UnsafeEnabled { - mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[10] + mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[12] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10780,7 +11788,7 @@ func (*QueryParamsRequest) ProtoMessage() {} // Deprecated: Use QueryParamsRequest.ProtoReflect.Descriptor instead. func (*QueryParamsRequest) Descriptor() ([]byte, []int) { - return file_cosmos_bank_v1beta1_query_proto_rawDescGZIP(), []int{10} + return file_cosmos_bank_v1beta1_query_proto_rawDescGZIP(), []int{12} } // QueryParamsResponse defines the response type for querying x/bank parameters. @@ -10795,7 +11803,7 @@ type QueryParamsResponse struct { func (x *QueryParamsResponse) Reset() { *x = QueryParamsResponse{} if protoimpl.UnsafeEnabled { - mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[11] + mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[13] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10809,7 +11817,7 @@ func (*QueryParamsResponse) ProtoMessage() {} // Deprecated: Use QueryParamsResponse.ProtoReflect.Descriptor instead. func (*QueryParamsResponse) Descriptor() ([]byte, []int) { - return file_cosmos_bank_v1beta1_query_proto_rawDescGZIP(), []int{11} + return file_cosmos_bank_v1beta1_query_proto_rawDescGZIP(), []int{13} } func (x *QueryParamsResponse) GetParams() *Params { @@ -10832,7 +11840,7 @@ type QueryDenomsMetadataRequest struct { func (x *QueryDenomsMetadataRequest) Reset() { *x = QueryDenomsMetadataRequest{} if protoimpl.UnsafeEnabled { - mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[12] + mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[14] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10846,7 +11854,7 @@ func (*QueryDenomsMetadataRequest) ProtoMessage() {} // Deprecated: Use QueryDenomsMetadataRequest.ProtoReflect.Descriptor instead. func (*QueryDenomsMetadataRequest) Descriptor() ([]byte, []int) { - return file_cosmos_bank_v1beta1_query_proto_rawDescGZIP(), []int{12} + return file_cosmos_bank_v1beta1_query_proto_rawDescGZIP(), []int{14} } func (x *QueryDenomsMetadataRequest) GetPagination() *v1beta11.PageRequest { @@ -10872,7 +11880,7 @@ type QueryDenomsMetadataResponse struct { func (x *QueryDenomsMetadataResponse) Reset() { *x = QueryDenomsMetadataResponse{} if protoimpl.UnsafeEnabled { - mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[13] + mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[15] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10886,7 +11894,7 @@ func (*QueryDenomsMetadataResponse) ProtoMessage() {} // Deprecated: Use QueryDenomsMetadataResponse.ProtoReflect.Descriptor instead. func (*QueryDenomsMetadataResponse) Descriptor() ([]byte, []int) { - return file_cosmos_bank_v1beta1_query_proto_rawDescGZIP(), []int{13} + return file_cosmos_bank_v1beta1_query_proto_rawDescGZIP(), []int{15} } func (x *QueryDenomsMetadataResponse) GetMetadatas() []*Metadata { @@ -10916,7 +11924,7 @@ type QueryDenomMetadataRequest struct { func (x *QueryDenomMetadataRequest) Reset() { *x = QueryDenomMetadataRequest{} if protoimpl.UnsafeEnabled { - mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[14] + mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[16] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10930,7 +11938,7 @@ func (*QueryDenomMetadataRequest) ProtoMessage() {} // Deprecated: Use QueryDenomMetadataRequest.ProtoReflect.Descriptor instead. func (*QueryDenomMetadataRequest) Descriptor() ([]byte, []int) { - return file_cosmos_bank_v1beta1_query_proto_rawDescGZIP(), []int{14} + return file_cosmos_bank_v1beta1_query_proto_rawDescGZIP(), []int{16} } func (x *QueryDenomMetadataRequest) GetDenom() string { @@ -10954,7 +11962,7 @@ type QueryDenomMetadataResponse struct { func (x *QueryDenomMetadataResponse) Reset() { *x = QueryDenomMetadataResponse{} if protoimpl.UnsafeEnabled { - mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[15] + mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[17] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -10968,7 +11976,7 @@ func (*QueryDenomMetadataResponse) ProtoMessage() {} // Deprecated: Use QueryDenomMetadataResponse.ProtoReflect.Descriptor instead. func (*QueryDenomMetadataResponse) Descriptor() ([]byte, []int) { - return file_cosmos_bank_v1beta1_query_proto_rawDescGZIP(), []int{15} + return file_cosmos_bank_v1beta1_query_proto_rawDescGZIP(), []int{17} } func (x *QueryDenomMetadataResponse) GetMetadata() *Metadata { @@ -10995,7 +12003,7 @@ type QueryDenomOwnersRequest struct { func (x *QueryDenomOwnersRequest) Reset() { *x = QueryDenomOwnersRequest{} if protoimpl.UnsafeEnabled { - mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[16] + mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[18] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11009,7 +12017,7 @@ func (*QueryDenomOwnersRequest) ProtoMessage() {} // Deprecated: Use QueryDenomOwnersRequest.ProtoReflect.Descriptor instead. func (*QueryDenomOwnersRequest) Descriptor() ([]byte, []int) { - return file_cosmos_bank_v1beta1_query_proto_rawDescGZIP(), []int{16} + return file_cosmos_bank_v1beta1_query_proto_rawDescGZIP(), []int{18} } func (x *QueryDenomOwnersRequest) GetDenom() string { @@ -11045,7 +12053,7 @@ type DenomOwner struct { func (x *DenomOwner) Reset() { *x = DenomOwner{} if protoimpl.UnsafeEnabled { - mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[17] + mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[19] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11059,7 +12067,7 @@ func (*DenomOwner) ProtoMessage() {} // Deprecated: Use DenomOwner.ProtoReflect.Descriptor instead. func (*DenomOwner) Descriptor() ([]byte, []int) { - return file_cosmos_bank_v1beta1_query_proto_rawDescGZIP(), []int{17} + return file_cosmos_bank_v1beta1_query_proto_rawDescGZIP(), []int{19} } func (x *DenomOwner) GetAddress() string { @@ -11092,7 +12100,7 @@ type QueryDenomOwnersResponse struct { func (x *QueryDenomOwnersResponse) Reset() { *x = QueryDenomOwnersResponse{} if protoimpl.UnsafeEnabled { - mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[18] + mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[20] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11106,7 +12114,7 @@ func (*QueryDenomOwnersResponse) ProtoMessage() {} // Deprecated: Use QueryDenomOwnersResponse.ProtoReflect.Descriptor instead. func (*QueryDenomOwnersResponse) Descriptor() ([]byte, []int) { - return file_cosmos_bank_v1beta1_query_proto_rawDescGZIP(), []int{18} + return file_cosmos_bank_v1beta1_query_proto_rawDescGZIP(), []int{20} } func (x *QueryDenomOwnersResponse) GetDenomOwners() []*DenomOwner { @@ -11141,7 +12149,7 @@ type QuerySendEnabledRequest struct { func (x *QuerySendEnabledRequest) Reset() { *x = QuerySendEnabledRequest{} if protoimpl.UnsafeEnabled { - mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[19] + mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[21] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11155,7 +12163,7 @@ func (*QuerySendEnabledRequest) ProtoMessage() {} // Deprecated: Use QuerySendEnabledRequest.ProtoReflect.Descriptor instead. func (*QuerySendEnabledRequest) Descriptor() ([]byte, []int) { - return file_cosmos_bank_v1beta1_query_proto_rawDescGZIP(), []int{19} + return file_cosmos_bank_v1beta1_query_proto_rawDescGZIP(), []int{21} } func (x *QuerySendEnabledRequest) GetDenoms() []string { @@ -11189,7 +12197,7 @@ type QuerySendEnabledResponse struct { func (x *QuerySendEnabledResponse) Reset() { *x = QuerySendEnabledResponse{} if protoimpl.UnsafeEnabled { - mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[20] + mi := &file_cosmos_bank_v1beta1_query_proto_msgTypes[22] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -11203,7 +12211,7 @@ func (*QuerySendEnabledResponse) ProtoMessage() {} // Deprecated: Use QuerySendEnabledResponse.ProtoReflect.Descriptor instead. func (*QuerySendEnabledResponse) Descriptor() ([]byte, []int) { - return file_cosmos_bank_v1beta1_query_proto_rawDescGZIP(), []int{20} + return file_cosmos_bank_v1beta1_query_proto_rawDescGZIP(), []int{22} } func (x *QuerySendEnabledResponse) GetSendEnabled() []*SendEnabled { @@ -11300,228 +12308,255 @@ var file_cosmos_bank_v1beta1_query_proto_rawDesc = []byte{ 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x22, 0x6b, 0x0a, 0x17, 0x51, 0x75, 0x65, 0x72, 0x79, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x53, - 0x75, 0x70, 0x70, 0x6c, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x46, 0x0a, 0x0a, - 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x26, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, - 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, - 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x3a, 0x08, 0x88, 0xa0, 0x1f, 0x00, 0xe8, 0xa0, 0x1f, 0x00, 0x22, 0xcd, - 0x01, 0x0a, 0x18, 0x51, 0x75, 0x65, 0x72, 0x79, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x53, 0x75, 0x70, - 0x70, 0x6c, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x68, 0x0a, 0x06, 0x73, - 0x75, 0x70, 0x70, 0x6c, 0x79, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x63, 0x6f, - 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, - 0x31, 0x2e, 0x43, 0x6f, 0x69, 0x6e, 0x42, 0x35, 0xc8, 0xde, 0x1f, 0x00, 0xaa, 0xdf, 0x1f, 0x28, - 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, - 0x73, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2d, 0x73, 0x64, 0x6b, 0x2f, 0x74, 0x79, 0x70, - 0x65, 0x73, 0x2e, 0x43, 0x6f, 0x69, 0x6e, 0x73, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x06, 0x73, - 0x75, 0x70, 0x70, 0x6c, 0x79, 0x12, 0x47, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x63, 0x6f, 0x73, 0x6d, - 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, - 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, - 0x0a, 0x14, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x4f, 0x66, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x64, 0x65, 0x6e, 0x6f, 0x6d, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x64, 0x65, 0x6e, 0x6f, 0x6d, 0x22, 0x55, 0x0a, 0x15, - 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x4f, 0x66, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3c, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, + 0x6e, 0x22, 0x79, 0x0a, 0x23, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x70, 0x65, 0x6e, 0x64, 0x61, + 0x62, 0x6c, 0x65, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x42, 0x79, 0x44, 0x65, 0x6e, 0x6f, + 0x6d, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x32, 0x0a, 0x07, 0x61, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x18, 0xd2, 0xb4, 0x2d, 0x14, 0x63, + 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, + 0x69, 0x6e, 0x67, 0x52, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x14, 0x0a, 0x05, + 0x64, 0x65, 0x6e, 0x6f, 0x6d, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x64, 0x65, 0x6e, + 0x6f, 0x6d, 0x3a, 0x08, 0x88, 0xa0, 0x1f, 0x00, 0xe8, 0xa0, 0x1f, 0x00, 0x22, 0x5b, 0x0a, 0x24, + 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x70, 0x65, 0x6e, 0x64, 0x61, 0x62, 0x6c, 0x65, 0x42, 0x61, + 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x42, 0x79, 0x44, 0x65, 0x6e, 0x6f, 0x6d, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x33, 0x0a, 0x07, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x43, 0x6f, 0x69, 0x6e, - 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x06, 0x61, 0x6d, 0x6f, - 0x75, 0x6e, 0x74, 0x22, 0x14, 0x0a, 0x12, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x72, 0x61, - 0x6d, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x55, 0x0a, 0x13, 0x51, 0x75, 0x65, - 0x72, 0x79, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x12, 0x3e, 0x0a, 0x06, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x1b, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x6e, 0x6b, 0x2e, 0x76, - 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x42, 0x09, 0xc8, - 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x06, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, - 0x22, 0x64, 0x0a, 0x1a, 0x51, 0x75, 0x65, 0x72, 0x79, 0x44, 0x65, 0x6e, 0x6f, 0x6d, 0x73, 0x4d, - 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x46, - 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, - 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, - 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, - 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xae, 0x01, 0x0a, 0x1b, 0x51, 0x75, 0x65, 0x72, 0x79, - 0x44, 0x65, 0x6e, 0x6f, 0x6d, 0x73, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x46, 0x0a, 0x09, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, - 0x74, 0x61, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x63, 0x6f, 0x73, 0x6d, - 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x6e, 0x6b, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, - 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, - 0xb0, 0x2a, 0x01, 0x52, 0x09, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x73, 0x12, 0x47, - 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, - 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, - 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x0a, 0x70, 0x61, 0x67, - 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x31, 0x0a, 0x19, 0x51, 0x75, 0x65, 0x72, 0x79, - 0x44, 0x65, 0x6e, 0x6f, 0x6d, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x64, 0x65, 0x6e, 0x6f, 0x6d, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x05, 0x64, 0x65, 0x6e, 0x6f, 0x6d, 0x22, 0x62, 0x0a, 0x1a, 0x51, 0x75, - 0x65, 0x72, 0x79, 0x44, 0x65, 0x6e, 0x6f, 0x6d, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x44, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, - 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x63, 0x6f, 0x73, - 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x6e, 0x6b, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, - 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8, - 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x22, 0x77, - 0x0a, 0x17, 0x51, 0x75, 0x65, 0x72, 0x79, 0x44, 0x65, 0x6e, 0x6f, 0x6d, 0x4f, 0x77, 0x6e, 0x65, - 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x64, 0x65, 0x6e, - 0x6f, 0x6d, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x64, 0x65, 0x6e, 0x6f, 0x6d, 0x12, - 0x46, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, - 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, - 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x0a, 0x70, 0x61, 0x67, - 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x80, 0x01, 0x0a, 0x0a, 0x44, 0x65, 0x6e, 0x6f, - 0x6d, 0x4f, 0x77, 0x6e, 0x65, 0x72, 0x12, 0x32, 0x0a, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, - 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x18, 0xd2, 0xb4, 0x2d, 0x14, 0x63, 0x6f, 0x73, - 0x6d, 0x6f, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, - 0x67, 0x52, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x3e, 0x0a, 0x07, 0x62, 0x61, - 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x63, 0x6f, - 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, - 0x31, 0x2e, 0x43, 0x6f, 0x69, 0x6e, 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, - 0x01, 0x52, 0x07, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0xa7, 0x01, 0x0a, 0x18, 0x51, - 0x75, 0x65, 0x72, 0x79, 0x44, 0x65, 0x6e, 0x6f, 0x6d, 0x4f, 0x77, 0x6e, 0x65, 0x72, 0x73, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x42, 0x0a, 0x0c, 0x64, 0x65, 0x6e, 0x6f, 0x6d, - 0x5f, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, - 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x6e, 0x6b, 0x2e, 0x76, 0x31, 0x62, 0x65, - 0x74, 0x61, 0x31, 0x2e, 0x44, 0x65, 0x6e, 0x6f, 0x6d, 0x4f, 0x77, 0x6e, 0x65, 0x72, 0x52, 0x0b, - 0x64, 0x65, 0x6e, 0x6f, 0x6d, 0x4f, 0x77, 0x6e, 0x65, 0x72, 0x73, 0x12, 0x47, 0x0a, 0x0a, 0x70, - 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x27, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, - 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x79, 0x0a, 0x17, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x65, 0x6e, - 0x64, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, - 0x16, 0x0a, 0x06, 0x64, 0x65, 0x6e, 0x6f, 0x6d, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, - 0x06, 0x64, 0x65, 0x6e, 0x6f, 0x6d, 0x73, 0x12, 0x46, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x63, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x63, 0x6f, + 0x52, 0x07, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x6b, 0x0a, 0x17, 0x51, 0x75, 0x65, + 0x72, 0x79, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x53, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x12, 0x46, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, + 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, + 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3a, 0x08, 0x88, 0xa0, + 0x1f, 0x00, 0xe8, 0xa0, 0x1f, 0x00, 0x22, 0xcd, 0x01, 0x0a, 0x18, 0x51, 0x75, 0x65, 0x72, 0x79, + 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x53, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x12, 0x68, 0x0a, 0x06, 0x73, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x18, 0x01, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, + 0x65, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x43, 0x6f, 0x69, 0x6e, 0x42, 0x35, + 0xc8, 0xde, 0x1f, 0x00, 0xaa, 0xdf, 0x1f, 0x28, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, + 0x6f, 0x6d, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, + 0x2d, 0x73, 0x64, 0x6b, 0x2f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x43, 0x6f, 0x69, 0x6e, 0x73, + 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x06, 0x73, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x12, 0x47, 0x0a, + 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x27, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, + 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, + 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, + 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x2c, 0x0a, 0x14, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, + 0x75, 0x70, 0x70, 0x6c, 0x79, 0x4f, 0x66, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x14, + 0x0a, 0x05, 0x64, 0x65, 0x6e, 0x6f, 0x6d, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x64, + 0x65, 0x6e, 0x6f, 0x6d, 0x22, 0x55, 0x0a, 0x15, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x75, 0x70, + 0x70, 0x6c, 0x79, 0x4f, 0x66, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3c, 0x0a, + 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, + 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x76, 0x31, 0x62, 0x65, + 0x74, 0x61, 0x31, 0x2e, 0x43, 0x6f, 0x69, 0x6e, 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, + 0xb0, 0x2a, 0x01, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x14, 0x0a, 0x12, 0x51, + 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x22, 0x55, 0x0a, 0x13, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3e, 0x0a, 0x06, 0x70, 0x61, 0x72, 0x61, + 0x6d, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, + 0x73, 0x2e, 0x62, 0x61, 0x6e, 0x6b, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, + 0x61, 0x72, 0x61, 0x6d, 0x73, 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, + 0x52, 0x06, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x64, 0x0a, 0x1a, 0x51, 0x75, 0x65, 0x72, + 0x79, 0x44, 0x65, 0x6e, 0x6f, 0x6d, 0x73, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x46, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x63, 0x6f, 0x73, + 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, + 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xae, + 0x01, 0x0a, 0x1b, 0x51, 0x75, 0x65, 0x72, 0x79, 0x44, 0x65, 0x6e, 0x6f, 0x6d, 0x73, 0x4d, 0x65, + 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x46, + 0x0a, 0x09, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x1d, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x6e, 0x6b, 0x2e, + 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, + 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x09, 0x6d, 0x65, 0x74, + 0x61, 0x64, 0x61, 0x74, 0x61, 0x73, 0x12, 0x47, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x63, 0x6f, 0x73, + 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, + 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, + 0x31, 0x0a, 0x19, 0x51, 0x75, 0x65, 0x72, 0x79, 0x44, 0x65, 0x6e, 0x6f, 0x6d, 0x4d, 0x65, 0x74, + 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x14, 0x0a, 0x05, + 0x64, 0x65, 0x6e, 0x6f, 0x6d, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x64, 0x65, 0x6e, + 0x6f, 0x6d, 0x22, 0x62, 0x0a, 0x1a, 0x51, 0x75, 0x65, 0x72, 0x79, 0x44, 0x65, 0x6e, 0x6f, 0x6d, + 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x12, 0x44, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x6e, 0x6b, + 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, + 0x61, 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x08, 0x6d, 0x65, + 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x22, 0x77, 0x0a, 0x17, 0x51, 0x75, 0x65, 0x72, 0x79, 0x44, + 0x65, 0x6e, 0x6f, 0x6d, 0x4f, 0x77, 0x6e, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x12, 0x14, 0x0a, 0x05, 0x64, 0x65, 0x6e, 0x6f, 0x6d, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x05, 0x64, 0x65, 0x6e, 0x6f, 0x6d, 0x12, 0x46, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, - 0xa8, 0x01, 0x0a, 0x18, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x65, 0x6e, 0x64, 0x45, 0x6e, 0x61, - 0x62, 0x6c, 0x65, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x43, 0x0a, 0x0c, - 0x73, 0x65, 0x6e, 0x64, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x18, 0x01, 0x20, 0x03, - 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x6e, 0x6b, - 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x53, 0x65, 0x6e, 0x64, 0x45, 0x6e, 0x61, - 0x62, 0x6c, 0x65, 0x64, 0x52, 0x0b, 0x73, 0x65, 0x6e, 0x64, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, - 0x64, 0x12, 0x47, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, - 0x63, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, - 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, - 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x0a, - 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x32, 0xd8, 0x0c, 0x0a, 0x05, 0x51, - 0x75, 0x65, 0x72, 0x79, 0x12, 0x9d, 0x01, 0x0a, 0x07, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, - 0x12, 0x28, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x6e, 0x6b, 0x2e, 0x76, - 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x42, 0x61, 0x6c, 0x61, - 0x6e, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x63, 0x6f, 0x73, + 0x80, 0x01, 0x0a, 0x0a, 0x44, 0x65, 0x6e, 0x6f, 0x6d, 0x4f, 0x77, 0x6e, 0x65, 0x72, 0x12, 0x32, + 0x0a, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, + 0x18, 0xd2, 0xb4, 0x2d, 0x14, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, + 0x73, 0x73, 0x12, 0x3e, 0x0a, 0x07, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, + 0x65, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x43, 0x6f, 0x69, 0x6e, 0x42, 0x09, + 0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x07, 0x62, 0x61, 0x6c, 0x61, 0x6e, + 0x63, 0x65, 0x22, 0xa7, 0x01, 0x0a, 0x18, 0x51, 0x75, 0x65, 0x72, 0x79, 0x44, 0x65, 0x6e, 0x6f, + 0x6d, 0x4f, 0x77, 0x6e, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, + 0x42, 0x0a, 0x0c, 0x64, 0x65, 0x6e, 0x6f, 0x6d, 0x5f, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x73, 0x18, + 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, + 0x61, 0x6e, 0x6b, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x44, 0x65, 0x6e, 0x6f, + 0x6d, 0x4f, 0x77, 0x6e, 0x65, 0x72, 0x52, 0x0b, 0x64, 0x65, 0x6e, 0x6f, 0x6d, 0x4f, 0x77, 0x6e, + 0x65, 0x72, 0x73, 0x12, 0x47, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, + 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, + 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x79, 0x0a, 0x17, + 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x65, 0x6e, 0x64, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x64, 0x65, 0x6e, 0x6f, 0x6d, + 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, 0x64, 0x65, 0x6e, 0x6f, 0x6d, 0x73, 0x12, + 0x46, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x63, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, + 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, + 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x0a, 0x70, 0x61, 0x67, + 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xa8, 0x01, 0x0a, 0x18, 0x51, 0x75, 0x65, 0x72, + 0x79, 0x53, 0x65, 0x6e, 0x64, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x43, 0x0a, 0x0c, 0x73, 0x65, 0x6e, 0x64, 0x5f, 0x65, 0x6e, 0x61, + 0x62, 0x6c, 0x65, 0x64, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x63, 0x6f, 0x73, + 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x6e, 0x6b, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, + 0x2e, 0x53, 0x65, 0x6e, 0x64, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x52, 0x0b, 0x73, 0x65, + 0x6e, 0x64, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x12, 0x47, 0x0a, 0x0a, 0x70, 0x61, 0x67, + 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x63, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, + 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, + 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x32, 0xb2, 0x0e, 0x0a, 0x05, 0x51, 0x75, 0x65, 0x72, 0x79, 0x12, 0x9d, 0x01, 0x0a, + 0x07, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x28, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, + 0x73, 0x2e, 0x62, 0x61, 0x6e, 0x6b, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, + 0x75, 0x65, 0x72, 0x79, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x6e, 0x6b, + 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x42, 0x61, + 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x3d, 0x88, + 0xe7, 0xb0, 0x2a, 0x01, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x32, 0x12, 0x30, 0x2f, 0x63, 0x6f, 0x73, + 0x6d, 0x6f, 0x73, 0x2f, 0x62, 0x61, 0x6e, 0x6b, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, + 0x2f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x2f, 0x7b, 0x61, 0x64, 0x64, 0x72, 0x65, + 0x73, 0x73, 0x7d, 0x2f, 0x62, 0x79, 0x5f, 0x64, 0x65, 0x6e, 0x6f, 0x6d, 0x12, 0xa0, 0x01, 0x0a, + 0x0b, 0x41, 0x6c, 0x6c, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x12, 0x2c, 0x2e, 0x63, + 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x6e, 0x6b, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, + 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x42, 0x61, 0x6c, 0x61, 0x6e, + 0x63, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2d, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x6e, 0x6b, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, - 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x3d, 0x88, 0xe7, 0xb0, 0x2a, 0x01, 0x82, 0xd3, 0xe4, 0x93, - 0x02, 0x32, 0x12, 0x30, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x62, 0x61, 0x6e, 0x6b, - 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, - 0x73, 0x2f, 0x7b, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x7d, 0x2f, 0x62, 0x79, 0x5f, 0x64, - 0x65, 0x6e, 0x6f, 0x6d, 0x12, 0xa0, 0x01, 0x0a, 0x0b, 0x41, 0x6c, 0x6c, 0x42, 0x61, 0x6c, 0x61, - 0x6e, 0x63, 0x65, 0x73, 0x12, 0x2c, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, + 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, 0x6c, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, + 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x34, 0x88, 0xe7, 0xb0, 0x2a, 0x01, + 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x29, 0x12, 0x27, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, + 0x62, 0x61, 0x6e, 0x6b, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x62, 0x61, 0x6c, + 0x61, 0x6e, 0x63, 0x65, 0x73, 0x2f, 0x7b, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x7d, 0x12, + 0xbc, 0x01, 0x0a, 0x11, 0x53, 0x70, 0x65, 0x6e, 0x64, 0x61, 0x62, 0x6c, 0x65, 0x42, 0x61, 0x6c, + 0x61, 0x6e, 0x63, 0x65, 0x73, 0x12, 0x32, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, + 0x61, 0x6e, 0x6b, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, + 0x79, 0x53, 0x70, 0x65, 0x6e, 0x64, 0x61, 0x62, 0x6c, 0x65, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, + 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x33, 0x2e, 0x63, 0x6f, 0x73, 0x6d, + 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x6e, 0x6b, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, + 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x70, 0x65, 0x6e, 0x64, 0x61, 0x62, 0x6c, 0x65, 0x42, 0x61, + 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x3e, + 0x88, 0xe7, 0xb0, 0x2a, 0x01, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x33, 0x12, 0x31, 0x2f, 0x63, 0x6f, + 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x62, 0x61, 0x6e, 0x6b, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, + 0x31, 0x2f, 0x73, 0x70, 0x65, 0x6e, 0x64, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x62, 0x61, 0x6c, 0x61, + 0x6e, 0x63, 0x65, 0x73, 0x2f, 0x7b, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x7d, 0x12, 0xd7, + 0x01, 0x0a, 0x17, 0x53, 0x70, 0x65, 0x6e, 0x64, 0x61, 0x62, 0x6c, 0x65, 0x42, 0x61, 0x6c, 0x61, + 0x6e, 0x63, 0x65, 0x42, 0x79, 0x44, 0x65, 0x6e, 0x6f, 0x6d, 0x12, 0x38, 0x2e, 0x63, 0x6f, 0x73, + 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x6e, 0x6b, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, + 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x70, 0x65, 0x6e, 0x64, 0x61, 0x62, 0x6c, 0x65, 0x42, + 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x42, 0x79, 0x44, 0x65, 0x6e, 0x6f, 0x6d, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x39, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x6e, 0x6b, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, - 0x41, 0x6c, 0x6c, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x1a, 0x2d, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x6e, 0x6b, - 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x6c, - 0x6c, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x22, 0x34, 0x88, 0xe7, 0xb0, 0x2a, 0x01, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x29, 0x12, 0x27, - 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x62, 0x61, 0x6e, 0x6b, 0x2f, 0x76, 0x31, 0x62, - 0x65, 0x74, 0x61, 0x31, 0x2f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x2f, 0x7b, 0x61, - 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x7d, 0x12, 0xbc, 0x01, 0x0a, 0x11, 0x53, 0x70, 0x65, 0x6e, - 0x64, 0x61, 0x62, 0x6c, 0x65, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x12, 0x32, 0x2e, - 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x6e, 0x6b, 0x2e, 0x76, 0x31, 0x62, 0x65, - 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x70, 0x65, 0x6e, 0x64, 0x61, 0x62, - 0x6c, 0x65, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, - 0x74, 0x1a, 0x33, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x6e, 0x6b, 0x2e, - 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x70, 0x65, - 0x6e, 0x64, 0x61, 0x62, 0x6c, 0x65, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x3e, 0x88, 0xe7, 0xb0, 0x2a, 0x01, 0x82, 0xd3, 0xe4, - 0x93, 0x02, 0x33, 0x12, 0x31, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x62, 0x61, 0x6e, - 0x6b, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x73, 0x70, 0x65, 0x6e, 0x64, 0x61, - 0x62, 0x6c, 0x65, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x2f, 0x7b, 0x61, 0x64, - 0x64, 0x72, 0x65, 0x73, 0x73, 0x7d, 0x12, 0x94, 0x01, 0x0a, 0x0b, 0x54, 0x6f, 0x74, 0x61, 0x6c, - 0x53, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x12, 0x2c, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, + 0x53, 0x70, 0x65, 0x6e, 0x64, 0x61, 0x62, 0x6c, 0x65, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, + 0x42, 0x79, 0x44, 0x65, 0x6e, 0x6f, 0x6d, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, + 0x47, 0x88, 0xe7, 0xb0, 0x2a, 0x01, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x3c, 0x12, 0x3a, 0x2f, 0x63, + 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x62, 0x61, 0x6e, 0x6b, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, + 0x61, 0x31, 0x2f, 0x73, 0x70, 0x65, 0x6e, 0x64, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x62, 0x61, 0x6c, + 0x61, 0x6e, 0x63, 0x65, 0x73, 0x2f, 0x7b, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x7d, 0x2f, + 0x62, 0x79, 0x5f, 0x64, 0x65, 0x6e, 0x6f, 0x6d, 0x12, 0x94, 0x01, 0x0a, 0x0b, 0x54, 0x6f, 0x74, + 0x61, 0x6c, 0x53, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x12, 0x2c, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, + 0x73, 0x2e, 0x62, 0x61, 0x6e, 0x6b, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, + 0x75, 0x65, 0x72, 0x79, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x53, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2d, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x6e, 0x6b, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, - 0x72, 0x79, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x53, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2d, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, - 0x6e, 0x6b, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, - 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x53, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x22, 0x28, 0x88, 0xe7, 0xb0, 0x2a, 0x01, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1d, - 0x12, 0x1b, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x62, 0x61, 0x6e, 0x6b, 0x2f, 0x76, - 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x73, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x12, 0x94, 0x01, - 0x0a, 0x08, 0x53, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x4f, 0x66, 0x12, 0x29, 0x2e, 0x63, 0x6f, 0x73, + 0x72, 0x79, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x53, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x28, 0x88, 0xe7, 0xb0, 0x2a, 0x01, 0x82, 0xd3, 0xe4, 0x93, + 0x02, 0x1d, 0x12, 0x1b, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x62, 0x61, 0x6e, 0x6b, + 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x73, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x12, + 0x94, 0x01, 0x0a, 0x08, 0x53, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x4f, 0x66, 0x12, 0x29, 0x2e, 0x63, + 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x6e, 0x6b, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, + 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x4f, 0x66, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, + 0x2e, 0x62, 0x61, 0x6e, 0x6b, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, + 0x65, 0x72, 0x79, 0x53, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x4f, 0x66, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x31, 0x88, 0xe7, 0xb0, 0x2a, 0x01, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x26, + 0x12, 0x24, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x62, 0x61, 0x6e, 0x6b, 0x2f, 0x76, + 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x73, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x2f, 0x62, 0x79, + 0x5f, 0x64, 0x65, 0x6e, 0x6f, 0x6d, 0x12, 0x85, 0x01, 0x0a, 0x06, 0x50, 0x61, 0x72, 0x61, 0x6d, + 0x73, 0x12, 0x27, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x6e, 0x6b, 0x2e, + 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x72, + 0x61, 0x6d, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x6e, 0x6b, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, - 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x4f, 0x66, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, - 0x61, 0x6e, 0x6b, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, - 0x79, 0x53, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x4f, 0x66, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x22, 0x31, 0x88, 0xe7, 0xb0, 0x2a, 0x01, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x26, 0x12, 0x24, + 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x28, 0x88, 0xe7, 0xb0, 0x2a, 0x01, 0x82, 0xd3, 0xe4, 0x93, 0x02, + 0x1d, 0x12, 0x1b, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x62, 0x61, 0x6e, 0x6b, 0x2f, + 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0xab, + 0x01, 0x0a, 0x0d, 0x44, 0x65, 0x6e, 0x6f, 0x6d, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, + 0x12, 0x2e, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x6e, 0x6b, 0x2e, 0x76, + 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x44, 0x65, 0x6e, 0x6f, + 0x6d, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x2f, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x6e, 0x6b, 0x2e, 0x76, + 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x44, 0x65, 0x6e, 0x6f, + 0x6d, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x22, 0x39, 0x88, 0xe7, 0xb0, 0x2a, 0x01, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x2e, 0x12, 0x2c, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x62, 0x61, 0x6e, 0x6b, 0x2f, 0x76, 0x31, 0x62, - 0x65, 0x74, 0x61, 0x31, 0x2f, 0x73, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x2f, 0x62, 0x79, 0x5f, 0x64, - 0x65, 0x6e, 0x6f, 0x6d, 0x12, 0x85, 0x01, 0x0a, 0x06, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, - 0x27, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x6e, 0x6b, 0x2e, 0x76, 0x31, - 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x72, 0x61, 0x6d, - 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, - 0x73, 0x2e, 0x62, 0x61, 0x6e, 0x6b, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, - 0x75, 0x65, 0x72, 0x79, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x22, 0x28, 0x88, 0xe7, 0xb0, 0x2a, 0x01, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1d, 0x12, - 0x1b, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x62, 0x61, 0x6e, 0x6b, 0x2f, 0x76, 0x31, - 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0xab, 0x01, 0x0a, - 0x0d, 0x44, 0x65, 0x6e, 0x6f, 0x6d, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x2e, - 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x6e, 0x6b, 0x2e, 0x76, 0x31, 0x62, - 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x44, 0x65, 0x6e, 0x6f, 0x6d, 0x4d, - 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2f, - 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x6e, 0x6b, 0x2e, 0x76, 0x31, 0x62, - 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x44, 0x65, 0x6e, 0x6f, 0x6d, 0x4d, - 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, - 0x39, 0x88, 0xe7, 0xb0, 0x2a, 0x01, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x2e, 0x12, 0x2c, 0x2f, 0x63, - 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x62, 0x61, 0x6e, 0x6b, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, - 0x61, 0x31, 0x2f, 0x64, 0x65, 0x6e, 0x6f, 0x6d, 0x73, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, - 0x74, 0x61, 0x2f, 0x7b, 0x64, 0x65, 0x6e, 0x6f, 0x6d, 0x7d, 0x12, 0xa6, 0x01, 0x0a, 0x0e, 0x44, - 0x65, 0x6e, 0x6f, 0x6d, 0x73, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x2f, 0x2e, - 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x6e, 0x6b, 0x2e, 0x76, 0x31, 0x62, 0x65, - 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x44, 0x65, 0x6e, 0x6f, 0x6d, 0x73, 0x4d, - 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x30, - 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x6e, 0x6b, 0x2e, 0x76, 0x31, 0x62, - 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x44, 0x65, 0x6e, 0x6f, 0x6d, 0x73, - 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x22, 0x31, 0x88, 0xe7, 0xb0, 0x2a, 0x01, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x26, 0x12, 0x24, 0x2f, - 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x62, 0x61, 0x6e, 0x6b, 0x2f, 0x76, 0x31, 0x62, 0x65, - 0x74, 0x61, 0x31, 0x2f, 0x64, 0x65, 0x6e, 0x6f, 0x6d, 0x73, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x64, - 0x61, 0x74, 0x61, 0x12, 0xa2, 0x01, 0x0a, 0x0b, 0x44, 0x65, 0x6e, 0x6f, 0x6d, 0x4f, 0x77, 0x6e, - 0x65, 0x72, 0x73, 0x12, 0x2c, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x6e, + 0x65, 0x74, 0x61, 0x31, 0x2f, 0x64, 0x65, 0x6e, 0x6f, 0x6d, 0x73, 0x5f, 0x6d, 0x65, 0x74, 0x61, + 0x64, 0x61, 0x74, 0x61, 0x2f, 0x7b, 0x64, 0x65, 0x6e, 0x6f, 0x6d, 0x7d, 0x12, 0xa6, 0x01, 0x0a, + 0x0e, 0x44, 0x65, 0x6e, 0x6f, 0x6d, 0x73, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, + 0x2f, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x6e, 0x6b, 0x2e, 0x76, 0x31, + 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x44, 0x65, 0x6e, 0x6f, 0x6d, + 0x73, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x30, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x6e, 0x6b, 0x2e, 0x76, + 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x44, 0x65, 0x6e, 0x6f, + 0x6d, 0x73, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x22, 0x31, 0x88, 0xe7, 0xb0, 0x2a, 0x01, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x26, 0x12, + 0x24, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x62, 0x61, 0x6e, 0x6b, 0x2f, 0x76, 0x31, + 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x64, 0x65, 0x6e, 0x6f, 0x6d, 0x73, 0x5f, 0x6d, 0x65, 0x74, + 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0xa2, 0x01, 0x0a, 0x0b, 0x44, 0x65, 0x6e, 0x6f, 0x6d, 0x4f, + 0x77, 0x6e, 0x65, 0x72, 0x73, 0x12, 0x2c, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, + 0x61, 0x6e, 0x6b, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, + 0x79, 0x44, 0x65, 0x6e, 0x6f, 0x6d, 0x4f, 0x77, 0x6e, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x2d, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x6e, 0x6b, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x44, - 0x65, 0x6e, 0x6f, 0x6d, 0x4f, 0x77, 0x6e, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, - 0x74, 0x1a, 0x2d, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x6e, 0x6b, 0x2e, - 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x44, 0x65, 0x6e, - 0x6f, 0x6d, 0x4f, 0x77, 0x6e, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x22, 0x36, 0x88, 0xe7, 0xb0, 0x2a, 0x01, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x2b, 0x12, 0x29, 0x2f, - 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x62, 0x61, 0x6e, 0x6b, 0x2f, 0x76, 0x31, 0x62, 0x65, - 0x74, 0x61, 0x31, 0x2f, 0x64, 0x65, 0x6e, 0x6f, 0x6d, 0x5f, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x73, - 0x2f, 0x7b, 0x64, 0x65, 0x6e, 0x6f, 0x6d, 0x7d, 0x12, 0x9a, 0x01, 0x0a, 0x0b, 0x53, 0x65, 0x6e, - 0x64, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x12, 0x2c, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, + 0x65, 0x6e, 0x6f, 0x6d, 0x4f, 0x77, 0x6e, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x22, 0x36, 0x88, 0xe7, 0xb0, 0x2a, 0x01, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x2b, 0x12, + 0x29, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x62, 0x61, 0x6e, 0x6b, 0x2f, 0x76, 0x31, + 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x64, 0x65, 0x6e, 0x6f, 0x6d, 0x5f, 0x6f, 0x77, 0x6e, 0x65, + 0x72, 0x73, 0x2f, 0x7b, 0x64, 0x65, 0x6e, 0x6f, 0x6d, 0x7d, 0x12, 0x9a, 0x01, 0x0a, 0x0b, 0x53, + 0x65, 0x6e, 0x64, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x12, 0x2c, 0x2e, 0x63, 0x6f, 0x73, + 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x6e, 0x6b, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, + 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x65, 0x6e, 0x64, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, + 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2d, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x6e, 0x6b, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x65, 0x6e, 0x64, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2d, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, - 0x62, 0x61, 0x6e, 0x6b, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, - 0x72, 0x79, 0x53, 0x65, 0x6e, 0x64, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2e, 0x88, 0xe7, 0xb0, 0x2a, 0x01, 0x82, 0xd3, 0xe4, 0x93, - 0x02, 0x23, 0x12, 0x21, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x62, 0x61, 0x6e, 0x6b, - 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x73, 0x65, 0x6e, 0x64, 0x5f, 0x65, 0x6e, - 0x61, 0x62, 0x6c, 0x65, 0x64, 0x42, 0xc5, 0x01, 0x0a, 0x17, 0x63, 0x6f, 0x6d, 0x2e, 0x63, 0x6f, - 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x6e, 0x6b, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, - 0x31, 0x42, 0x0a, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, - 0x30, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x61, 0x70, - 0x69, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x62, 0x61, 0x6e, 0x6b, 0x2f, 0x76, 0x31, - 0x62, 0x65, 0x74, 0x61, 0x31, 0x3b, 0x62, 0x61, 0x6e, 0x6b, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, - 0x31, 0xa2, 0x02, 0x03, 0x43, 0x42, 0x58, 0xaa, 0x02, 0x13, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, - 0x2e, 0x42, 0x61, 0x6e, 0x6b, 0x2e, 0x56, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0xca, 0x02, 0x13, - 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5c, 0x42, 0x61, 0x6e, 0x6b, 0x5c, 0x56, 0x31, 0x62, 0x65, - 0x74, 0x61, 0x31, 0xe2, 0x02, 0x1f, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5c, 0x42, 0x61, 0x6e, - 0x6b, 0x5c, 0x56, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, - 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x15, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x3a, 0x3a, - 0x42, 0x61, 0x6e, 0x6b, 0x3a, 0x3a, 0x56, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x62, 0x06, 0x70, - 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2e, 0x88, 0xe7, 0xb0, 0x2a, 0x01, 0x82, 0xd3, + 0xe4, 0x93, 0x02, 0x23, 0x12, 0x21, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x62, 0x61, + 0x6e, 0x6b, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x73, 0x65, 0x6e, 0x64, 0x5f, + 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x42, 0xc5, 0x01, 0x0a, 0x17, 0x63, 0x6f, 0x6d, 0x2e, + 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x6e, 0x6b, 0x2e, 0x76, 0x31, 0x62, 0x65, + 0x74, 0x61, 0x31, 0x42, 0x0a, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, + 0x01, 0x5a, 0x30, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, + 0x61, 0x70, 0x69, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x62, 0x61, 0x6e, 0x6b, 0x2f, + 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x3b, 0x62, 0x61, 0x6e, 0x6b, 0x76, 0x31, 0x62, 0x65, + 0x74, 0x61, 0x31, 0xa2, 0x02, 0x03, 0x43, 0x42, 0x58, 0xaa, 0x02, 0x13, 0x43, 0x6f, 0x73, 0x6d, + 0x6f, 0x73, 0x2e, 0x42, 0x61, 0x6e, 0x6b, 0x2e, 0x56, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0xca, + 0x02, 0x13, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5c, 0x42, 0x61, 0x6e, 0x6b, 0x5c, 0x56, 0x31, + 0x62, 0x65, 0x74, 0x61, 0x31, 0xe2, 0x02, 0x1f, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5c, 0x42, + 0x61, 0x6e, 0x6b, 0x5c, 0x56, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, + 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x15, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, + 0x3a, 0x3a, 0x42, 0x61, 0x6e, 0x6b, 0x3a, 0x3a, 0x56, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x62, + 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, } var ( @@ -11536,85 +12571,90 @@ func file_cosmos_bank_v1beta1_query_proto_rawDescGZIP() []byte { return file_cosmos_bank_v1beta1_query_proto_rawDescData } -var file_cosmos_bank_v1beta1_query_proto_msgTypes = make([]protoimpl.MessageInfo, 21) +var file_cosmos_bank_v1beta1_query_proto_msgTypes = make([]protoimpl.MessageInfo, 23) var file_cosmos_bank_v1beta1_query_proto_goTypes = []interface{}{ - (*QueryBalanceRequest)(nil), // 0: cosmos.bank.v1beta1.QueryBalanceRequest - (*QueryBalanceResponse)(nil), // 1: cosmos.bank.v1beta1.QueryBalanceResponse - (*QueryAllBalancesRequest)(nil), // 2: cosmos.bank.v1beta1.QueryAllBalancesRequest - (*QueryAllBalancesResponse)(nil), // 3: cosmos.bank.v1beta1.QueryAllBalancesResponse - (*QuerySpendableBalancesRequest)(nil), // 4: cosmos.bank.v1beta1.QuerySpendableBalancesRequest - (*QuerySpendableBalancesResponse)(nil), // 5: cosmos.bank.v1beta1.QuerySpendableBalancesResponse - (*QueryTotalSupplyRequest)(nil), // 6: cosmos.bank.v1beta1.QueryTotalSupplyRequest - (*QueryTotalSupplyResponse)(nil), // 7: cosmos.bank.v1beta1.QueryTotalSupplyResponse - (*QuerySupplyOfRequest)(nil), // 8: cosmos.bank.v1beta1.QuerySupplyOfRequest - (*QuerySupplyOfResponse)(nil), // 9: cosmos.bank.v1beta1.QuerySupplyOfResponse - (*QueryParamsRequest)(nil), // 10: cosmos.bank.v1beta1.QueryParamsRequest - (*QueryParamsResponse)(nil), // 11: cosmos.bank.v1beta1.QueryParamsResponse - (*QueryDenomsMetadataRequest)(nil), // 12: cosmos.bank.v1beta1.QueryDenomsMetadataRequest - (*QueryDenomsMetadataResponse)(nil), // 13: cosmos.bank.v1beta1.QueryDenomsMetadataResponse - (*QueryDenomMetadataRequest)(nil), // 14: cosmos.bank.v1beta1.QueryDenomMetadataRequest - (*QueryDenomMetadataResponse)(nil), // 15: cosmos.bank.v1beta1.QueryDenomMetadataResponse - (*QueryDenomOwnersRequest)(nil), // 16: cosmos.bank.v1beta1.QueryDenomOwnersRequest - (*DenomOwner)(nil), // 17: cosmos.bank.v1beta1.DenomOwner - (*QueryDenomOwnersResponse)(nil), // 18: cosmos.bank.v1beta1.QueryDenomOwnersResponse - (*QuerySendEnabledRequest)(nil), // 19: cosmos.bank.v1beta1.QuerySendEnabledRequest - (*QuerySendEnabledResponse)(nil), // 20: cosmos.bank.v1beta1.QuerySendEnabledResponse - (*v1beta1.Coin)(nil), // 21: cosmos.base.v1beta1.Coin - (*v1beta11.PageRequest)(nil), // 22: cosmos.base.query.v1beta1.PageRequest - (*v1beta11.PageResponse)(nil), // 23: cosmos.base.query.v1beta1.PageResponse - (*Params)(nil), // 24: cosmos.bank.v1beta1.Params - (*Metadata)(nil), // 25: cosmos.bank.v1beta1.Metadata - (*SendEnabled)(nil), // 26: cosmos.bank.v1beta1.SendEnabled + (*QueryBalanceRequest)(nil), // 0: cosmos.bank.v1beta1.QueryBalanceRequest + (*QueryBalanceResponse)(nil), // 1: cosmos.bank.v1beta1.QueryBalanceResponse + (*QueryAllBalancesRequest)(nil), // 2: cosmos.bank.v1beta1.QueryAllBalancesRequest + (*QueryAllBalancesResponse)(nil), // 3: cosmos.bank.v1beta1.QueryAllBalancesResponse + (*QuerySpendableBalancesRequest)(nil), // 4: cosmos.bank.v1beta1.QuerySpendableBalancesRequest + (*QuerySpendableBalancesResponse)(nil), // 5: cosmos.bank.v1beta1.QuerySpendableBalancesResponse + (*QuerySpendableBalanceByDenomRequest)(nil), // 6: cosmos.bank.v1beta1.QuerySpendableBalanceByDenomRequest + (*QuerySpendableBalanceByDenomResponse)(nil), // 7: cosmos.bank.v1beta1.QuerySpendableBalanceByDenomResponse + (*QueryTotalSupplyRequest)(nil), // 8: cosmos.bank.v1beta1.QueryTotalSupplyRequest + (*QueryTotalSupplyResponse)(nil), // 9: cosmos.bank.v1beta1.QueryTotalSupplyResponse + (*QuerySupplyOfRequest)(nil), // 10: cosmos.bank.v1beta1.QuerySupplyOfRequest + (*QuerySupplyOfResponse)(nil), // 11: cosmos.bank.v1beta1.QuerySupplyOfResponse + (*QueryParamsRequest)(nil), // 12: cosmos.bank.v1beta1.QueryParamsRequest + (*QueryParamsResponse)(nil), // 13: cosmos.bank.v1beta1.QueryParamsResponse + (*QueryDenomsMetadataRequest)(nil), // 14: cosmos.bank.v1beta1.QueryDenomsMetadataRequest + (*QueryDenomsMetadataResponse)(nil), // 15: cosmos.bank.v1beta1.QueryDenomsMetadataResponse + (*QueryDenomMetadataRequest)(nil), // 16: cosmos.bank.v1beta1.QueryDenomMetadataRequest + (*QueryDenomMetadataResponse)(nil), // 17: cosmos.bank.v1beta1.QueryDenomMetadataResponse + (*QueryDenomOwnersRequest)(nil), // 18: cosmos.bank.v1beta1.QueryDenomOwnersRequest + (*DenomOwner)(nil), // 19: cosmos.bank.v1beta1.DenomOwner + (*QueryDenomOwnersResponse)(nil), // 20: cosmos.bank.v1beta1.QueryDenomOwnersResponse + (*QuerySendEnabledRequest)(nil), // 21: cosmos.bank.v1beta1.QuerySendEnabledRequest + (*QuerySendEnabledResponse)(nil), // 22: cosmos.bank.v1beta1.QuerySendEnabledResponse + (*v1beta1.Coin)(nil), // 23: cosmos.base.v1beta1.Coin + (*v1beta11.PageRequest)(nil), // 24: cosmos.base.query.v1beta1.PageRequest + (*v1beta11.PageResponse)(nil), // 25: cosmos.base.query.v1beta1.PageResponse + (*Params)(nil), // 26: cosmos.bank.v1beta1.Params + (*Metadata)(nil), // 27: cosmos.bank.v1beta1.Metadata + (*SendEnabled)(nil), // 28: cosmos.bank.v1beta1.SendEnabled } var file_cosmos_bank_v1beta1_query_proto_depIdxs = []int32{ - 21, // 0: cosmos.bank.v1beta1.QueryBalanceResponse.balance:type_name -> cosmos.base.v1beta1.Coin - 22, // 1: cosmos.bank.v1beta1.QueryAllBalancesRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest - 21, // 2: cosmos.bank.v1beta1.QueryAllBalancesResponse.balances:type_name -> cosmos.base.v1beta1.Coin - 23, // 3: cosmos.bank.v1beta1.QueryAllBalancesResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse - 22, // 4: cosmos.bank.v1beta1.QuerySpendableBalancesRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest - 21, // 5: cosmos.bank.v1beta1.QuerySpendableBalancesResponse.balances:type_name -> cosmos.base.v1beta1.Coin - 23, // 6: cosmos.bank.v1beta1.QuerySpendableBalancesResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse - 22, // 7: cosmos.bank.v1beta1.QueryTotalSupplyRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest - 21, // 8: cosmos.bank.v1beta1.QueryTotalSupplyResponse.supply:type_name -> cosmos.base.v1beta1.Coin - 23, // 9: cosmos.bank.v1beta1.QueryTotalSupplyResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse - 21, // 10: cosmos.bank.v1beta1.QuerySupplyOfResponse.amount:type_name -> cosmos.base.v1beta1.Coin - 24, // 11: cosmos.bank.v1beta1.QueryParamsResponse.params:type_name -> cosmos.bank.v1beta1.Params - 22, // 12: cosmos.bank.v1beta1.QueryDenomsMetadataRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest - 25, // 13: cosmos.bank.v1beta1.QueryDenomsMetadataResponse.metadatas:type_name -> cosmos.bank.v1beta1.Metadata - 23, // 14: cosmos.bank.v1beta1.QueryDenomsMetadataResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse - 25, // 15: cosmos.bank.v1beta1.QueryDenomMetadataResponse.metadata:type_name -> cosmos.bank.v1beta1.Metadata - 22, // 16: cosmos.bank.v1beta1.QueryDenomOwnersRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest - 21, // 17: cosmos.bank.v1beta1.DenomOwner.balance:type_name -> cosmos.base.v1beta1.Coin - 17, // 18: cosmos.bank.v1beta1.QueryDenomOwnersResponse.denom_owners:type_name -> cosmos.bank.v1beta1.DenomOwner - 23, // 19: cosmos.bank.v1beta1.QueryDenomOwnersResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse - 22, // 20: cosmos.bank.v1beta1.QuerySendEnabledRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest - 26, // 21: cosmos.bank.v1beta1.QuerySendEnabledResponse.send_enabled:type_name -> cosmos.bank.v1beta1.SendEnabled - 23, // 22: cosmos.bank.v1beta1.QuerySendEnabledResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse - 0, // 23: cosmos.bank.v1beta1.Query.Balance:input_type -> cosmos.bank.v1beta1.QueryBalanceRequest - 2, // 24: cosmos.bank.v1beta1.Query.AllBalances:input_type -> cosmos.bank.v1beta1.QueryAllBalancesRequest - 4, // 25: cosmos.bank.v1beta1.Query.SpendableBalances:input_type -> cosmos.bank.v1beta1.QuerySpendableBalancesRequest - 6, // 26: cosmos.bank.v1beta1.Query.TotalSupply:input_type -> cosmos.bank.v1beta1.QueryTotalSupplyRequest - 8, // 27: cosmos.bank.v1beta1.Query.SupplyOf:input_type -> cosmos.bank.v1beta1.QuerySupplyOfRequest - 10, // 28: cosmos.bank.v1beta1.Query.Params:input_type -> cosmos.bank.v1beta1.QueryParamsRequest - 14, // 29: cosmos.bank.v1beta1.Query.DenomMetadata:input_type -> cosmos.bank.v1beta1.QueryDenomMetadataRequest - 12, // 30: cosmos.bank.v1beta1.Query.DenomsMetadata:input_type -> cosmos.bank.v1beta1.QueryDenomsMetadataRequest - 16, // 31: cosmos.bank.v1beta1.Query.DenomOwners:input_type -> cosmos.bank.v1beta1.QueryDenomOwnersRequest - 19, // 32: cosmos.bank.v1beta1.Query.SendEnabled:input_type -> cosmos.bank.v1beta1.QuerySendEnabledRequest - 1, // 33: cosmos.bank.v1beta1.Query.Balance:output_type -> cosmos.bank.v1beta1.QueryBalanceResponse - 3, // 34: cosmos.bank.v1beta1.Query.AllBalances:output_type -> cosmos.bank.v1beta1.QueryAllBalancesResponse - 5, // 35: cosmos.bank.v1beta1.Query.SpendableBalances:output_type -> cosmos.bank.v1beta1.QuerySpendableBalancesResponse - 7, // 36: cosmos.bank.v1beta1.Query.TotalSupply:output_type -> cosmos.bank.v1beta1.QueryTotalSupplyResponse - 9, // 37: cosmos.bank.v1beta1.Query.SupplyOf:output_type -> cosmos.bank.v1beta1.QuerySupplyOfResponse - 11, // 38: cosmos.bank.v1beta1.Query.Params:output_type -> cosmos.bank.v1beta1.QueryParamsResponse - 15, // 39: cosmos.bank.v1beta1.Query.DenomMetadata:output_type -> cosmos.bank.v1beta1.QueryDenomMetadataResponse - 13, // 40: cosmos.bank.v1beta1.Query.DenomsMetadata:output_type -> cosmos.bank.v1beta1.QueryDenomsMetadataResponse - 18, // 41: cosmos.bank.v1beta1.Query.DenomOwners:output_type -> cosmos.bank.v1beta1.QueryDenomOwnersResponse - 20, // 42: cosmos.bank.v1beta1.Query.SendEnabled:output_type -> cosmos.bank.v1beta1.QuerySendEnabledResponse - 33, // [33:43] is the sub-list for method output_type - 23, // [23:33] is the sub-list for method input_type - 23, // [23:23] is the sub-list for extension type_name - 23, // [23:23] is the sub-list for extension extendee - 0, // [0:23] is the sub-list for field type_name + 23, // 0: cosmos.bank.v1beta1.QueryBalanceResponse.balance:type_name -> cosmos.base.v1beta1.Coin + 24, // 1: cosmos.bank.v1beta1.QueryAllBalancesRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest + 23, // 2: cosmos.bank.v1beta1.QueryAllBalancesResponse.balances:type_name -> cosmos.base.v1beta1.Coin + 25, // 3: cosmos.bank.v1beta1.QueryAllBalancesResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse + 24, // 4: cosmos.bank.v1beta1.QuerySpendableBalancesRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest + 23, // 5: cosmos.bank.v1beta1.QuerySpendableBalancesResponse.balances:type_name -> cosmos.base.v1beta1.Coin + 25, // 6: cosmos.bank.v1beta1.QuerySpendableBalancesResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse + 23, // 7: cosmos.bank.v1beta1.QuerySpendableBalanceByDenomResponse.balance:type_name -> cosmos.base.v1beta1.Coin + 24, // 8: cosmos.bank.v1beta1.QueryTotalSupplyRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest + 23, // 9: cosmos.bank.v1beta1.QueryTotalSupplyResponse.supply:type_name -> cosmos.base.v1beta1.Coin + 25, // 10: cosmos.bank.v1beta1.QueryTotalSupplyResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse + 23, // 11: cosmos.bank.v1beta1.QuerySupplyOfResponse.amount:type_name -> cosmos.base.v1beta1.Coin + 26, // 12: cosmos.bank.v1beta1.QueryParamsResponse.params:type_name -> cosmos.bank.v1beta1.Params + 24, // 13: cosmos.bank.v1beta1.QueryDenomsMetadataRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest + 27, // 14: cosmos.bank.v1beta1.QueryDenomsMetadataResponse.metadatas:type_name -> cosmos.bank.v1beta1.Metadata + 25, // 15: cosmos.bank.v1beta1.QueryDenomsMetadataResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse + 27, // 16: cosmos.bank.v1beta1.QueryDenomMetadataResponse.metadata:type_name -> cosmos.bank.v1beta1.Metadata + 24, // 17: cosmos.bank.v1beta1.QueryDenomOwnersRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest + 23, // 18: cosmos.bank.v1beta1.DenomOwner.balance:type_name -> cosmos.base.v1beta1.Coin + 19, // 19: cosmos.bank.v1beta1.QueryDenomOwnersResponse.denom_owners:type_name -> cosmos.bank.v1beta1.DenomOwner + 25, // 20: cosmos.bank.v1beta1.QueryDenomOwnersResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse + 24, // 21: cosmos.bank.v1beta1.QuerySendEnabledRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest + 28, // 22: cosmos.bank.v1beta1.QuerySendEnabledResponse.send_enabled:type_name -> cosmos.bank.v1beta1.SendEnabled + 25, // 23: cosmos.bank.v1beta1.QuerySendEnabledResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse + 0, // 24: cosmos.bank.v1beta1.Query.Balance:input_type -> cosmos.bank.v1beta1.QueryBalanceRequest + 2, // 25: cosmos.bank.v1beta1.Query.AllBalances:input_type -> cosmos.bank.v1beta1.QueryAllBalancesRequest + 4, // 26: cosmos.bank.v1beta1.Query.SpendableBalances:input_type -> cosmos.bank.v1beta1.QuerySpendableBalancesRequest + 6, // 27: cosmos.bank.v1beta1.Query.SpendableBalanceByDenom:input_type -> cosmos.bank.v1beta1.QuerySpendableBalanceByDenomRequest + 8, // 28: cosmos.bank.v1beta1.Query.TotalSupply:input_type -> cosmos.bank.v1beta1.QueryTotalSupplyRequest + 10, // 29: cosmos.bank.v1beta1.Query.SupplyOf:input_type -> cosmos.bank.v1beta1.QuerySupplyOfRequest + 12, // 30: cosmos.bank.v1beta1.Query.Params:input_type -> cosmos.bank.v1beta1.QueryParamsRequest + 16, // 31: cosmos.bank.v1beta1.Query.DenomMetadata:input_type -> cosmos.bank.v1beta1.QueryDenomMetadataRequest + 14, // 32: cosmos.bank.v1beta1.Query.DenomsMetadata:input_type -> cosmos.bank.v1beta1.QueryDenomsMetadataRequest + 18, // 33: cosmos.bank.v1beta1.Query.DenomOwners:input_type -> cosmos.bank.v1beta1.QueryDenomOwnersRequest + 21, // 34: cosmos.bank.v1beta1.Query.SendEnabled:input_type -> cosmos.bank.v1beta1.QuerySendEnabledRequest + 1, // 35: cosmos.bank.v1beta1.Query.Balance:output_type -> cosmos.bank.v1beta1.QueryBalanceResponse + 3, // 36: cosmos.bank.v1beta1.Query.AllBalances:output_type -> cosmos.bank.v1beta1.QueryAllBalancesResponse + 5, // 37: cosmos.bank.v1beta1.Query.SpendableBalances:output_type -> cosmos.bank.v1beta1.QuerySpendableBalancesResponse + 7, // 38: cosmos.bank.v1beta1.Query.SpendableBalanceByDenom:output_type -> cosmos.bank.v1beta1.QuerySpendableBalanceByDenomResponse + 9, // 39: cosmos.bank.v1beta1.Query.TotalSupply:output_type -> cosmos.bank.v1beta1.QueryTotalSupplyResponse + 11, // 40: cosmos.bank.v1beta1.Query.SupplyOf:output_type -> cosmos.bank.v1beta1.QuerySupplyOfResponse + 13, // 41: cosmos.bank.v1beta1.Query.Params:output_type -> cosmos.bank.v1beta1.QueryParamsResponse + 17, // 42: cosmos.bank.v1beta1.Query.DenomMetadata:output_type -> cosmos.bank.v1beta1.QueryDenomMetadataResponse + 15, // 43: cosmos.bank.v1beta1.Query.DenomsMetadata:output_type -> cosmos.bank.v1beta1.QueryDenomsMetadataResponse + 20, // 44: cosmos.bank.v1beta1.Query.DenomOwners:output_type -> cosmos.bank.v1beta1.QueryDenomOwnersResponse + 22, // 45: cosmos.bank.v1beta1.Query.SendEnabled:output_type -> cosmos.bank.v1beta1.QuerySendEnabledResponse + 35, // [35:46] is the sub-list for method output_type + 24, // [24:35] is the sub-list for method input_type + 24, // [24:24] is the sub-list for extension type_name + 24, // [24:24] is the sub-list for extension extendee + 0, // [0:24] is the sub-list for field type_name } func init() { file_cosmos_bank_v1beta1_query_proto_init() } @@ -11697,7 +12737,7 @@ func file_cosmos_bank_v1beta1_query_proto_init() { } } file_cosmos_bank_v1beta1_query_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*QueryTotalSupplyRequest); i { + switch v := v.(*QuerySpendableBalanceByDenomRequest); i { case 0: return &v.state case 1: @@ -11709,7 +12749,7 @@ func file_cosmos_bank_v1beta1_query_proto_init() { } } file_cosmos_bank_v1beta1_query_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*QueryTotalSupplyResponse); i { + switch v := v.(*QuerySpendableBalanceByDenomResponse); i { case 0: return &v.state case 1: @@ -11721,7 +12761,7 @@ func file_cosmos_bank_v1beta1_query_proto_init() { } } file_cosmos_bank_v1beta1_query_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*QuerySupplyOfRequest); i { + switch v := v.(*QueryTotalSupplyRequest); i { case 0: return &v.state case 1: @@ -11733,7 +12773,7 @@ func file_cosmos_bank_v1beta1_query_proto_init() { } } file_cosmos_bank_v1beta1_query_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*QuerySupplyOfResponse); i { + switch v := v.(*QueryTotalSupplyResponse); i { case 0: return &v.state case 1: @@ -11745,7 +12785,7 @@ func file_cosmos_bank_v1beta1_query_proto_init() { } } file_cosmos_bank_v1beta1_query_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*QueryParamsRequest); i { + switch v := v.(*QuerySupplyOfRequest); i { case 0: return &v.state case 1: @@ -11757,7 +12797,7 @@ func file_cosmos_bank_v1beta1_query_proto_init() { } } file_cosmos_bank_v1beta1_query_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*QueryParamsResponse); i { + switch v := v.(*QuerySupplyOfResponse); i { case 0: return &v.state case 1: @@ -11769,7 +12809,7 @@ func file_cosmos_bank_v1beta1_query_proto_init() { } } file_cosmos_bank_v1beta1_query_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*QueryDenomsMetadataRequest); i { + switch v := v.(*QueryParamsRequest); i { case 0: return &v.state case 1: @@ -11781,7 +12821,7 @@ func file_cosmos_bank_v1beta1_query_proto_init() { } } file_cosmos_bank_v1beta1_query_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*QueryDenomsMetadataResponse); i { + switch v := v.(*QueryParamsResponse); i { case 0: return &v.state case 1: @@ -11793,7 +12833,7 @@ func file_cosmos_bank_v1beta1_query_proto_init() { } } file_cosmos_bank_v1beta1_query_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*QueryDenomMetadataRequest); i { + switch v := v.(*QueryDenomsMetadataRequest); i { case 0: return &v.state case 1: @@ -11805,7 +12845,7 @@ func file_cosmos_bank_v1beta1_query_proto_init() { } } file_cosmos_bank_v1beta1_query_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*QueryDenomMetadataResponse); i { + switch v := v.(*QueryDenomsMetadataResponse); i { case 0: return &v.state case 1: @@ -11817,7 +12857,7 @@ func file_cosmos_bank_v1beta1_query_proto_init() { } } file_cosmos_bank_v1beta1_query_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*QueryDenomOwnersRequest); i { + switch v := v.(*QueryDenomMetadataRequest); i { case 0: return &v.state case 1: @@ -11829,7 +12869,7 @@ func file_cosmos_bank_v1beta1_query_proto_init() { } } file_cosmos_bank_v1beta1_query_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DenomOwner); i { + switch v := v.(*QueryDenomMetadataResponse); i { case 0: return &v.state case 1: @@ -11841,7 +12881,7 @@ func file_cosmos_bank_v1beta1_query_proto_init() { } } file_cosmos_bank_v1beta1_query_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*QueryDenomOwnersResponse); i { + switch v := v.(*QueryDenomOwnersRequest); i { case 0: return &v.state case 1: @@ -11853,7 +12893,7 @@ func file_cosmos_bank_v1beta1_query_proto_init() { } } file_cosmos_bank_v1beta1_query_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*QuerySendEnabledRequest); i { + switch v := v.(*DenomOwner); i { case 0: return &v.state case 1: @@ -11865,6 +12905,30 @@ func file_cosmos_bank_v1beta1_query_proto_init() { } } file_cosmos_bank_v1beta1_query_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryDenomOwnersResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cosmos_bank_v1beta1_query_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QuerySendEnabledRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cosmos_bank_v1beta1_query_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*QuerySendEnabledResponse); i { case 0: return &v.state @@ -11883,7 +12947,7 @@ func file_cosmos_bank_v1beta1_query_proto_init() { GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: file_cosmos_bank_v1beta1_query_proto_rawDesc, NumEnums: 0, - NumMessages: 21, + NumMessages: 23, NumExtensions: 0, NumServices: 1, }, diff --git a/api/cosmos/bank/v1beta1/query_grpc.pb.go b/api/cosmos/bank/v1beta1/query_grpc.pb.go index dfef4cd9d5b7..1814a7da9eb5 100644 --- a/api/cosmos/bank/v1beta1/query_grpc.pb.go +++ b/api/cosmos/bank/v1beta1/query_grpc.pb.go @@ -29,7 +29,7 @@ type QueryClient interface { // When called from another module, this query might consume a high amount of // gas if the pagination field is incorrectly set. AllBalances(ctx context.Context, in *QueryAllBalancesRequest, opts ...grpc.CallOption) (*QueryAllBalancesResponse, error) - // SpendableBalances queries the spenable balance of all coins for a single + // SpendableBalances queries the spendable balance of all coins for a single // account. // // When called from another module, this query might consume a high amount of @@ -37,6 +37,14 @@ type QueryClient interface { // // Since: cosmos-sdk 0.46 SpendableBalances(ctx context.Context, in *QuerySpendableBalancesRequest, opts ...grpc.CallOption) (*QuerySpendableBalancesResponse, error) + // SpendableBalanceByDenom queries the spendable balance of a single denom for + // a single account. + // + // When called from another module, this query might consume a high amount of + // gas if the pagination field is incorrectly set. + // + // Since: cosmos-sdk 0.47 + SpendableBalanceByDenom(ctx context.Context, in *QuerySpendableBalanceByDenomRequest, opts ...grpc.CallOption) (*QuerySpendableBalanceByDenomResponse, error) // TotalSupply queries the total supply of all coins. // // When called from another module, this query might consume a high amount of @@ -107,6 +115,15 @@ func (c *queryClient) SpendableBalances(ctx context.Context, in *QuerySpendableB return out, nil } +func (c *queryClient) SpendableBalanceByDenom(ctx context.Context, in *QuerySpendableBalanceByDenomRequest, opts ...grpc.CallOption) (*QuerySpendableBalanceByDenomResponse, error) { + out := new(QuerySpendableBalanceByDenomResponse) + err := c.cc.Invoke(ctx, "/cosmos.bank.v1beta1.Query/SpendableBalanceByDenom", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *queryClient) TotalSupply(ctx context.Context, in *QueryTotalSupplyRequest, opts ...grpc.CallOption) (*QueryTotalSupplyResponse, error) { out := new(QueryTotalSupplyResponse) err := c.cc.Invoke(ctx, "/cosmos.bank.v1beta1.Query/TotalSupply", in, out, opts...) @@ -181,7 +198,7 @@ type QueryServer interface { // When called from another module, this query might consume a high amount of // gas if the pagination field is incorrectly set. AllBalances(context.Context, *QueryAllBalancesRequest) (*QueryAllBalancesResponse, error) - // SpendableBalances queries the spenable balance of all coins for a single + // SpendableBalances queries the spendable balance of all coins for a single // account. // // When called from another module, this query might consume a high amount of @@ -189,6 +206,14 @@ type QueryServer interface { // // Since: cosmos-sdk 0.46 SpendableBalances(context.Context, *QuerySpendableBalancesRequest) (*QuerySpendableBalancesResponse, error) + // SpendableBalanceByDenom queries the spendable balance of a single denom for + // a single account. + // + // When called from another module, this query might consume a high amount of + // gas if the pagination field is incorrectly set. + // + // Since: cosmos-sdk 0.47 + SpendableBalanceByDenom(context.Context, *QuerySpendableBalanceByDenomRequest) (*QuerySpendableBalanceByDenomResponse, error) // TotalSupply queries the total supply of all coins. // // When called from another module, this query might consume a high amount of @@ -238,6 +263,9 @@ func (UnimplementedQueryServer) AllBalances(context.Context, *QueryAllBalancesRe func (UnimplementedQueryServer) SpendableBalances(context.Context, *QuerySpendableBalancesRequest) (*QuerySpendableBalancesResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method SpendableBalances not implemented") } +func (UnimplementedQueryServer) SpendableBalanceByDenom(context.Context, *QuerySpendableBalanceByDenomRequest) (*QuerySpendableBalanceByDenomResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method SpendableBalanceByDenom not implemented") +} func (UnimplementedQueryServer) TotalSupply(context.Context, *QueryTotalSupplyRequest) (*QueryTotalSupplyResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method TotalSupply not implemented") } @@ -326,6 +354,24 @@ func _Query_SpendableBalances_Handler(srv interface{}, ctx context.Context, dec return interceptor(ctx, in, info, handler) } +func _Query_SpendableBalanceByDenom_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QuerySpendableBalanceByDenomRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).SpendableBalanceByDenom(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmos.bank.v1beta1.Query/SpendableBalanceByDenom", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).SpendableBalanceByDenom(ctx, req.(*QuerySpendableBalanceByDenomRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _Query_TotalSupply_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(QueryTotalSupplyRequest) if err := dec(in); err != nil { @@ -471,6 +517,10 @@ var Query_ServiceDesc = grpc.ServiceDesc{ MethodName: "SpendableBalances", Handler: _Query_SpendableBalances_Handler, }, + { + MethodName: "SpendableBalanceByDenom", + Handler: _Query_SpendableBalanceByDenom_Handler, + }, { MethodName: "TotalSupply", Handler: _Query_TotalSupply_Handler, diff --git a/proto/cosmos/bank/v1beta1/query.proto b/proto/cosmos/bank/v1beta1/query.proto index 36cd5dfdb139..7abc31bacbf1 100644 --- a/proto/cosmos/bank/v1beta1/query.proto +++ b/proto/cosmos/bank/v1beta1/query.proto @@ -29,7 +29,7 @@ service Query { option (google.api.http).get = "/cosmos/bank/v1beta1/balances/{address}"; } - // SpendableBalances queries the spenable balance of all coins for a single + // SpendableBalances queries the spendable balance of all coins for a single // account. // // When called from another module, this query might consume a high amount of @@ -41,6 +41,18 @@ service Query { option (google.api.http).get = "/cosmos/bank/v1beta1/spendable_balances/{address}"; } + // SpendableBalanceByDenom queries the spendable balance of a single denom for + // a single account. + // + // When called from another module, this query might consume a high amount of + // gas if the pagination field is incorrectly set. + // + // Since: cosmos-sdk 0.47 + rpc SpendableBalanceByDenom(QuerySpendableBalanceByDenomRequest) returns (QuerySpendableBalanceByDenomResponse) { + option (cosmos.query.v1.module_query_safe) = true; + option (google.api.http).get = "/cosmos/bank/v1beta1/spendable_balances/{address}/by_denom"; + } + // TotalSupply queries the total supply of all coins. // // When called from another module, this query might consume a high amount of @@ -178,6 +190,31 @@ message QuerySpendableBalancesResponse { cosmos.base.query.v1beta1.PageResponse pagination = 2; } +// QuerySpendableBalanceByDenomRequest defines the gRPC request structure for +// querying an account's spendable balance for a specific denom. +// +// Since: cosmos-sdk 0.47 +message QuerySpendableBalanceByDenomRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // address is the address to query balances for. + string address = 1 [(cosmos_proto.scalar) = "cosmos.AddressString"]; + + // denom is the coin denom to query balances for. + string denom = 2; +} + +// QuerySpendableBalanceByDenomResponse defines the gRPC response structure for +// querying an account's spendable balance for a specific denom. +// +// Since: cosmos-sdk 0.47 +message QuerySpendableBalanceByDenomResponse { + // balance is the balance of the coin. + cosmos.base.v1beta1.Coin balance = 1; +} + + // QueryTotalSupplyRequest is the request type for the Query/TotalSupply RPC // method. message QueryTotalSupplyRequest { diff --git a/x/bank/client/cli/query.go b/x/bank/client/cli/query.go index e3f0045e0e56..6726ae2f5acf 100644 --- a/x/bank/client/cli/query.go +++ b/x/bank/client/cli/query.go @@ -111,24 +111,21 @@ Example: func GetSpendableBalancesCmd() *cobra.Command { cmd := &cobra.Command{ - Use: "spendable-balances [address]", - Short: "Query for account spendable balances by address", - Long: strings.TrimSpace( - fmt.Sprintf(`Query the spendable balances of an account. - -Example: - $ %s query %s spendable-balances [address] -`, - version.AppName, types.ModuleName, - ), - ), - Args: cobra.ExactArgs(1), + Use: "spendable-balances [address]", + Short: "Query for account spendable balances by address", + Example: fmt.Sprintf("$ %s query %s spendable-balances [address]", version.AppName, types.ModuleName), + Args: cobra.ExactArgs(1), RunE: func(cmd *cobra.Command, args []string) error { clientCtx, err := client.GetClientQueryContext(cmd) if err != nil { return err } + denom, err := cmd.Flags().GetString(FlagDenom) + if err != nil { + return err + } + queryClient := types.NewQueryClient(clientCtx) addr, err := sdk.AccAddressFromBech32(args[0]) @@ -142,9 +139,21 @@ Example: } ctx := cmd.Context() - params := types.NewQuerySpendableBalancesRequest(addr, pageReq) - res, err := queryClient.SpendableBalances(ctx, params) + if denom == "" { + params := types.NewQuerySpendableBalancesRequest(addr, pageReq) + + res, err := queryClient.SpendableBalances(ctx, params) + if err != nil { + return err + } + + return clientCtx.PrintProto(res) + } + + params := types.NewQuerySpendableBalanceByDenomRequest(addr, denom) + + res, err := queryClient.SpendableBalanceByDenom(ctx, params) if err != nil { return err } @@ -153,6 +162,7 @@ Example: }, } + cmd.Flags().String(FlagDenom, "", "The specific balance denomination to query for") flags.AddQueryFlagsToCmd(cmd) flags.AddPaginationFlagsToCmd(cmd, "spendable balances") diff --git a/x/bank/client/cli/query_test.go b/x/bank/client/cli/query_test.go index a4e2440eca38..75d5e03c1c58 100644 --- a/x/bank/client/cli/query_test.go +++ b/x/bank/client/cli/query_test.go @@ -149,6 +149,23 @@ func (s *CLITestSuite) TestGetSpendableBalancesCmd() { &types.QuerySpendableBalancesResponse{}, false, }, + { + "valid query with denom flag", + func() client.Context { + bz, _ := s.encCfg.Codec.Marshal(&types.QuerySpendableBalanceByDenomRequest{}) + c := clitestutil.NewMockTendermintRPC(abci.ResponseQuery{ + Value: bz, + }) + return s.baseCtx.WithClient(c) + }, + []string{ + accounts[0].Address.String(), + fmt.Sprintf("--%s=json", flags.FlagOutput), + fmt.Sprintf("--%s=photon", cli.FlagDenom), + }, + &types.QuerySpendableBalanceByDenomResponse{}, + false, + }, { "invalid Address", func() client.Context { diff --git a/x/bank/keeper/grpc_query.go b/x/bank/keeper/grpc_query.go index f1c5b3081bb7..ada58b235f04 100644 --- a/x/bank/keeper/grpc_query.go +++ b/x/bank/keeper/grpc_query.go @@ -22,10 +22,6 @@ func (k BaseKeeper) Balance(ctx context.Context, req *types.QueryBalanceRequest) return nil, status.Error(codes.InvalidArgument, "empty request") } - if req.Address == "" { - return nil, status.Error(codes.InvalidArgument, "address cannot be empty") - } - if req.Denom == "" { return nil, status.Error(codes.InvalidArgument, "invalid denom") } @@ -47,10 +43,6 @@ func (k BaseKeeper) AllBalances(ctx context.Context, req *types.QueryAllBalances return nil, status.Error(codes.InvalidArgument, "empty request") } - if req.Address == "" { - return nil, status.Error(codes.InvalidArgument, "address cannot be empty") - } - addr, err := sdk.AccAddressFromBech32(req.Address) if err != nil { return nil, status.Errorf(codes.InvalidArgument, "invalid address: %s", err.Error()) @@ -113,6 +105,29 @@ func (k BaseKeeper) SpendableBalances(ctx context.Context, req *types.QuerySpend return &types.QuerySpendableBalancesResponse{Balances: result, Pagination: pageRes}, nil } +// SpendableBalanceByDenom implements a gRPC query handler for retrieving an account's +// spendable balance for a specific denom. +func (k BaseKeeper) SpendableBalanceByDenom(ctx context.Context, req *types.QuerySpendableBalanceByDenomRequest) (*types.QuerySpendableBalanceByDenomResponse, error) { + if req == nil { + return nil, status.Error(codes.InvalidArgument, "empty request") + } + + addr, err := sdk.AccAddressFromBech32(req.Address) + if err != nil { + return nil, status.Errorf(codes.InvalidArgument, "invalid address: %s", err.Error()) + } + + if req.Denom == "" { + return nil, status.Error(codes.InvalidArgument, "invalid denom") + } + + sdkCtx := sdk.UnwrapSDKContext(ctx) + + spendable := k.SpendableCoin(sdkCtx, addr, req.Denom) + + return &types.QuerySpendableBalanceByDenomResponse{Balance: &spendable}, nil +} + // TotalSupply implements the Query/TotalSupply gRPC method func (k BaseKeeper) TotalSupply(ctx context.Context, req *types.QueryTotalSupplyRequest) (*types.QueryTotalSupplyResponse, error) { sdkCtx := sdk.UnwrapSDKContext(ctx) diff --git a/x/bank/keeper/grpc_query_test.go b/x/bank/keeper/grpc_query_test.go index 63a344ea5fa7..4593aed464c9 100644 --- a/x/bank/keeper/grpc_query_test.go +++ b/x/bank/keeper/grpc_query_test.go @@ -137,6 +137,58 @@ func (suite *KeeperTestSuite) TestSpendableBalances() { suite.EqualValues(25, res.Balances[1].Amount.Int64()) } +func (suite *KeeperTestSuite) TestSpendableBalanceByDenom() { + ctx := suite.ctx + _, _, addr := testdata.KeyTestPubAddr() + ctx = ctx.WithBlockTime(time.Now()) + queryClient := suite.mockQueryClient(ctx) + + _, err := queryClient.SpendableBalanceByDenom(ctx, &types.QuerySpendableBalanceByDenomRequest{}) + suite.Require().Error(err) + + req := types.NewQuerySpendableBalanceByDenomRequest(addr, fooDenom) + acc := authtypes.NewBaseAccountWithAddress(addr) + + suite.mockSpendableCoins(ctx, acc) + res, err := queryClient.SpendableBalanceByDenom(ctx, req) + suite.Require().NoError(err) + suite.Require().NotNil(res) + suite.True(res.Balance.IsZero()) + + fooCoins := newFooCoin(100) + barCoins := newBarCoin(30) + + origCoins := sdk.NewCoins(fooCoins, barCoins) + vacc := vestingtypes.NewContinuousVestingAccount( + acc, + sdk.NewCoins(fooCoins), + ctx.BlockTime().Unix(), + ctx.BlockTime().Add(time.Hour).Unix(), + ) + + suite.mockFundAccount(addr) + suite.Require().NoError(testutil.FundAccount(suite.bankKeeper, suite.ctx, addr, origCoins)) + + // move time forward for half of the tokens to vest + ctx = ctx.WithBlockTime(ctx.BlockTime().Add(30 * time.Minute)) + queryClient = suite.mockQueryClient(ctx) + + // check fooCoins first, it has some vested and some vesting + suite.mockSpendableCoins(ctx, vacc) + res, err = queryClient.SpendableBalanceByDenom(ctx, req) + suite.Require().NoError(err) + suite.Require().NotNil(res) + suite.EqualValues(50, res.Balance.Amount.Int64()) + + // check barCoins, all of it is spendable + req.Denom = barDenom + suite.mockSpendableCoins(ctx, vacc) + res, err = queryClient.SpendableBalanceByDenom(ctx, req) + suite.Require().NoError(err) + suite.Require().NotNil(res) + suite.EqualValues(30, res.Balance.Amount.Int64()) +} + func (suite *KeeperTestSuite) TestQueryTotalSupply() { ctx, queryClient := suite.ctx, suite.queryClient res, err := queryClient.TotalSupply(gocontext.Background(), &types.QueryTotalSupplyRequest{}) diff --git a/x/bank/types/querier.go b/x/bank/types/querier.go index 3ffe7a320fa8..a21605b71f3c 100644 --- a/x/bank/types/querier.go +++ b/x/bank/types/querier.go @@ -35,6 +35,14 @@ func NewQuerySpendableBalancesRequest(addr sdk.AccAddress, req *query.PageReques return &QuerySpendableBalancesRequest{Address: addr.String(), Pagination: req} } +// NewQuerySpendableBalanceByDenomRequest creates a new instance of a +// QuerySpendableBalanceByDenomRequest. +// +//nolint:interfacer +func NewQuerySpendableBalanceByDenomRequest(addr sdk.AccAddress, denom string) *QuerySpendableBalanceByDenomRequest { + return &QuerySpendableBalanceByDenomRequest{Address: addr.String(), Denom: denom} +} + // QueryTotalSupplyParams defines the params for the following queries: // // - 'custom/bank/totalSupply' diff --git a/x/bank/types/query.pb.go b/x/bank/types/query.pb.go index daa2d99cf019..7f8c6931b6c9 100644 --- a/x/bank/types/query.pb.go +++ b/x/bank/types/query.pb.go @@ -320,6 +320,99 @@ func (m *QuerySpendableBalancesResponse) GetPagination() *query.PageResponse { return nil } +// QuerySpendableBalanceByDenomRequest defines the gRPC request structure for +// querying an account's spendable balance for a specific denom. +// +// Since: cosmos-sdk 0.47 +type QuerySpendableBalanceByDenomRequest struct { + // address is the address to query balances for. + Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` + // denom is the coin denom to query balances for. + Denom string `protobuf:"bytes,2,opt,name=denom,proto3" json:"denom,omitempty"` +} + +func (m *QuerySpendableBalanceByDenomRequest) Reset() { *m = QuerySpendableBalanceByDenomRequest{} } +func (m *QuerySpendableBalanceByDenomRequest) String() string { return proto.CompactTextString(m) } +func (*QuerySpendableBalanceByDenomRequest) ProtoMessage() {} +func (*QuerySpendableBalanceByDenomRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_9c6fc1939682df13, []int{6} +} +func (m *QuerySpendableBalanceByDenomRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QuerySpendableBalanceByDenomRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QuerySpendableBalanceByDenomRequest.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 *QuerySpendableBalanceByDenomRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QuerySpendableBalanceByDenomRequest.Merge(m, src) +} +func (m *QuerySpendableBalanceByDenomRequest) XXX_Size() int { + return m.Size() +} +func (m *QuerySpendableBalanceByDenomRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QuerySpendableBalanceByDenomRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QuerySpendableBalanceByDenomRequest proto.InternalMessageInfo + +// QuerySpendableBalanceByDenomResponse defines the gRPC response structure for +// querying an account's spendable balance for a specific denom. +// +// Since: cosmos-sdk 0.47 +type QuerySpendableBalanceByDenomResponse struct { + // balance is the balance of the coin. + Balance *types.Coin `protobuf:"bytes,1,opt,name=balance,proto3" json:"balance,omitempty"` +} + +func (m *QuerySpendableBalanceByDenomResponse) Reset() { *m = QuerySpendableBalanceByDenomResponse{} } +func (m *QuerySpendableBalanceByDenomResponse) String() string { return proto.CompactTextString(m) } +func (*QuerySpendableBalanceByDenomResponse) ProtoMessage() {} +func (*QuerySpendableBalanceByDenomResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_9c6fc1939682df13, []int{7} +} +func (m *QuerySpendableBalanceByDenomResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QuerySpendableBalanceByDenomResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QuerySpendableBalanceByDenomResponse.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 *QuerySpendableBalanceByDenomResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QuerySpendableBalanceByDenomResponse.Merge(m, src) +} +func (m *QuerySpendableBalanceByDenomResponse) XXX_Size() int { + return m.Size() +} +func (m *QuerySpendableBalanceByDenomResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QuerySpendableBalanceByDenomResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QuerySpendableBalanceByDenomResponse proto.InternalMessageInfo + +func (m *QuerySpendableBalanceByDenomResponse) GetBalance() *types.Coin { + if m != nil { + return m.Balance + } + return nil +} + // QueryTotalSupplyRequest is the request type for the Query/TotalSupply RPC // method. type QueryTotalSupplyRequest struct { @@ -333,7 +426,7 @@ func (m *QueryTotalSupplyRequest) Reset() { *m = QueryTotalSupplyRequest func (m *QueryTotalSupplyRequest) String() string { return proto.CompactTextString(m) } func (*QueryTotalSupplyRequest) ProtoMessage() {} func (*QueryTotalSupplyRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_9c6fc1939682df13, []int{6} + return fileDescriptor_9c6fc1939682df13, []int{8} } func (m *QueryTotalSupplyRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -377,7 +470,7 @@ func (m *QueryTotalSupplyResponse) Reset() { *m = QueryTotalSupplyRespon func (m *QueryTotalSupplyResponse) String() string { return proto.CompactTextString(m) } func (*QueryTotalSupplyResponse) ProtoMessage() {} func (*QueryTotalSupplyResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_9c6fc1939682df13, []int{7} + return fileDescriptor_9c6fc1939682df13, []int{9} } func (m *QueryTotalSupplyResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -430,7 +523,7 @@ func (m *QuerySupplyOfRequest) Reset() { *m = QuerySupplyOfRequest{} } func (m *QuerySupplyOfRequest) String() string { return proto.CompactTextString(m) } func (*QuerySupplyOfRequest) ProtoMessage() {} func (*QuerySupplyOfRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_9c6fc1939682df13, []int{8} + return fileDescriptor_9c6fc1939682df13, []int{10} } func (m *QuerySupplyOfRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -476,7 +569,7 @@ func (m *QuerySupplyOfResponse) Reset() { *m = QuerySupplyOfResponse{} } func (m *QuerySupplyOfResponse) String() string { return proto.CompactTextString(m) } func (*QuerySupplyOfResponse) ProtoMessage() {} func (*QuerySupplyOfResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_9c6fc1939682df13, []int{9} + return fileDescriptor_9c6fc1939682df13, []int{11} } func (m *QuerySupplyOfResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -520,7 +613,7 @@ 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_9c6fc1939682df13, []int{10} + return fileDescriptor_9c6fc1939682df13, []int{12} } func (m *QueryParamsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -558,7 +651,7 @@ 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_9c6fc1939682df13, []int{11} + return fileDescriptor_9c6fc1939682df13, []int{13} } func (m *QueryParamsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -604,7 +697,7 @@ func (m *QueryDenomsMetadataRequest) Reset() { *m = QueryDenomsMetadataR func (m *QueryDenomsMetadataRequest) String() string { return proto.CompactTextString(m) } func (*QueryDenomsMetadataRequest) ProtoMessage() {} func (*QueryDenomsMetadataRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_9c6fc1939682df13, []int{12} + return fileDescriptor_9c6fc1939682df13, []int{14} } func (m *QueryDenomsMetadataRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -653,7 +746,7 @@ func (m *QueryDenomsMetadataResponse) Reset() { *m = QueryDenomsMetadata func (m *QueryDenomsMetadataResponse) String() string { return proto.CompactTextString(m) } func (*QueryDenomsMetadataResponse) ProtoMessage() {} func (*QueryDenomsMetadataResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_9c6fc1939682df13, []int{13} + return fileDescriptor_9c6fc1939682df13, []int{15} } func (m *QueryDenomsMetadataResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -706,7 +799,7 @@ func (m *QueryDenomMetadataRequest) Reset() { *m = QueryDenomMetadataReq func (m *QueryDenomMetadataRequest) String() string { return proto.CompactTextString(m) } func (*QueryDenomMetadataRequest) ProtoMessage() {} func (*QueryDenomMetadataRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_9c6fc1939682df13, []int{14} + return fileDescriptor_9c6fc1939682df13, []int{16} } func (m *QueryDenomMetadataRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -753,7 +846,7 @@ func (m *QueryDenomMetadataResponse) Reset() { *m = QueryDenomMetadataRe func (m *QueryDenomMetadataResponse) String() string { return proto.CompactTextString(m) } func (*QueryDenomMetadataResponse) ProtoMessage() {} func (*QueryDenomMetadataResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_9c6fc1939682df13, []int{15} + return fileDescriptor_9c6fc1939682df13, []int{17} } func (m *QueryDenomMetadataResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -803,7 +896,7 @@ func (m *QueryDenomOwnersRequest) Reset() { *m = QueryDenomOwnersRequest func (m *QueryDenomOwnersRequest) String() string { return proto.CompactTextString(m) } func (*QueryDenomOwnersRequest) ProtoMessage() {} func (*QueryDenomOwnersRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_9c6fc1939682df13, []int{16} + return fileDescriptor_9c6fc1939682df13, []int{18} } func (m *QueryDenomOwnersRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -862,7 +955,7 @@ func (m *DenomOwner) Reset() { *m = DenomOwner{} } func (m *DenomOwner) String() string { return proto.CompactTextString(m) } func (*DenomOwner) ProtoMessage() {} func (*DenomOwner) Descriptor() ([]byte, []int) { - return fileDescriptor_9c6fc1939682df13, []int{17} + return fileDescriptor_9c6fc1939682df13, []int{19} } func (m *DenomOwner) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -918,7 +1011,7 @@ func (m *QueryDenomOwnersResponse) Reset() { *m = QueryDenomOwnersRespon func (m *QueryDenomOwnersResponse) String() string { return proto.CompactTextString(m) } func (*QueryDenomOwnersResponse) ProtoMessage() {} func (*QueryDenomOwnersResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_9c6fc1939682df13, []int{18} + return fileDescriptor_9c6fc1939682df13, []int{20} } func (m *QueryDenomOwnersResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -976,7 +1069,7 @@ func (m *QuerySendEnabledRequest) Reset() { *m = QuerySendEnabledRequest func (m *QuerySendEnabledRequest) String() string { return proto.CompactTextString(m) } func (*QuerySendEnabledRequest) ProtoMessage() {} func (*QuerySendEnabledRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_9c6fc1939682df13, []int{19} + return fileDescriptor_9c6fc1939682df13, []int{21} } func (m *QuerySendEnabledRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1033,7 +1126,7 @@ func (m *QuerySendEnabledResponse) Reset() { *m = QuerySendEnabledRespon func (m *QuerySendEnabledResponse) String() string { return proto.CompactTextString(m) } func (*QuerySendEnabledResponse) ProtoMessage() {} func (*QuerySendEnabledResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_9c6fc1939682df13, []int{20} + return fileDescriptor_9c6fc1939682df13, []int{22} } func (m *QuerySendEnabledResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1083,6 +1176,8 @@ func init() { proto.RegisterType((*QueryAllBalancesResponse)(nil), "cosmos.bank.v1beta1.QueryAllBalancesResponse") proto.RegisterType((*QuerySpendableBalancesRequest)(nil), "cosmos.bank.v1beta1.QuerySpendableBalancesRequest") proto.RegisterType((*QuerySpendableBalancesResponse)(nil), "cosmos.bank.v1beta1.QuerySpendableBalancesResponse") + proto.RegisterType((*QuerySpendableBalanceByDenomRequest)(nil), "cosmos.bank.v1beta1.QuerySpendableBalanceByDenomRequest") + proto.RegisterType((*QuerySpendableBalanceByDenomResponse)(nil), "cosmos.bank.v1beta1.QuerySpendableBalanceByDenomResponse") proto.RegisterType((*QueryTotalSupplyRequest)(nil), "cosmos.bank.v1beta1.QueryTotalSupplyRequest") proto.RegisterType((*QueryTotalSupplyResponse)(nil), "cosmos.bank.v1beta1.QueryTotalSupplyResponse") proto.RegisterType((*QuerySupplyOfRequest)(nil), "cosmos.bank.v1beta1.QuerySupplyOfRequest") @@ -1103,78 +1198,82 @@ func init() { func init() { proto.RegisterFile("cosmos/bank/v1beta1/query.proto", fileDescriptor_9c6fc1939682df13) } var fileDescriptor_9c6fc1939682df13 = []byte{ - // 1135 bytes of a gzipped FileDescriptorProto + // 1188 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x58, 0xcf, 0x6f, 0x1b, 0x45, - 0x14, 0xf6, 0x14, 0xd5, 0x49, 0x9e, 0x03, 0x52, 0xa7, 0x01, 0x92, 0x0d, 0xb1, 0xcb, 0x82, 0x1a, - 0x27, 0x24, 0xbb, 0xb5, 0x03, 0x48, 0x20, 0x88, 0x54, 0xa7, 0x94, 0x03, 0x42, 0x2d, 0x0e, 0xbd, - 0x70, 0xb1, 0xc6, 0xde, 0xc1, 0xb5, 0x62, 0xef, 0xb8, 0x9e, 0x35, 0xc5, 0xaa, 0x2a, 0x21, 0x24, - 0xa4, 0x1e, 0x91, 0xe8, 0x09, 0x09, 0x11, 0x21, 0x01, 0x15, 0x48, 0x88, 0x03, 0x47, 0xfe, 0x80, - 0x5e, 0x90, 0x0a, 0x1c, 0xe8, 0x09, 0x50, 0x82, 0x04, 0x7f, 0x06, 0xf2, 0xfc, 0xf0, 0xee, 0xda, - 0xe3, 0x8d, 0x1b, 0x8c, 0x04, 0x97, 0xd6, 0x9e, 0x79, 0x6f, 0xde, 0xf7, 0x7d, 0xef, 0xcd, 0xbc, - 0xe7, 0x40, 0xae, 0xc6, 0x78, 0x8b, 0x71, 0xb7, 0x4a, 0xfc, 0x3d, 0xf7, 0x9d, 0x42, 0x95, 0x06, - 0xa4, 0xe0, 0x5e, 0xeb, 0xd2, 0x4e, 0xcf, 0x69, 0x77, 0x58, 0xc0, 0xf0, 0x69, 0x69, 0xe0, 0xf4, - 0x0d, 0x1c, 0x65, 0x60, 0xad, 0x0f, 0xbc, 0x38, 0x95, 0xd6, 0x03, 0xdf, 0x36, 0xa9, 0x37, 0x7c, - 0x12, 0x34, 0x98, 0x2f, 0x0f, 0xb0, 0x16, 0xea, 0xac, 0xce, 0xc4, 0x47, 0xb7, 0xff, 0x49, 0xad, - 0x3e, 0x51, 0x67, 0xac, 0xde, 0xa4, 0x2e, 0x69, 0x37, 0x5c, 0xe2, 0xfb, 0x2c, 0x10, 0x2e, 0x5c, - 0xed, 0x66, 0xa3, 0xe7, 0xeb, 0x93, 0x6b, 0xac, 0xe1, 0x8f, 0xec, 0x47, 0x50, 0x0b, 0x84, 0x72, - 0x7f, 0x49, 0xee, 0x57, 0x64, 0x58, 0xc5, 0x40, 0x6e, 0x2d, 0x2b, 0x57, 0x8d, 0x3a, 0x4a, 0xd6, - 0x3a, 0x45, 0x5a, 0x0d, 0x9f, 0xb9, 0xe2, 0x5f, 0xb9, 0x64, 0x37, 0xe0, 0xf4, 0x1b, 0x7d, 0x8b, - 0x12, 0x69, 0x12, 0xbf, 0x46, 0xcb, 0xf4, 0x5a, 0x97, 0xf2, 0x00, 0x17, 0x61, 0x86, 0x78, 0x5e, - 0x87, 0x72, 0xbe, 0x88, 0xce, 0xa0, 0xfc, 0x5c, 0x69, 0xf1, 0xa7, 0xef, 0x36, 0x17, 0x54, 0xa4, - 0xf3, 0x72, 0x67, 0x37, 0xe8, 0x34, 0xfc, 0x7a, 0x59, 0x1b, 0xe2, 0x05, 0x38, 0xe9, 0x51, 0x9f, - 0xb5, 0x16, 0x4f, 0xf4, 0x3d, 0xca, 0xf2, 0xcb, 0x8b, 0xb3, 0xb7, 0xf6, 0x73, 0xa9, 0xbf, 0xf6, - 0x73, 0x29, 0xfb, 0x35, 0x58, 0x88, 0x87, 0xe2, 0x6d, 0xe6, 0x73, 0x8a, 0xb7, 0x60, 0xa6, 0x2a, - 0x97, 0x44, 0xac, 0x4c, 0x71, 0xc9, 0x19, 0x24, 0x85, 0x53, 0x9d, 0x14, 0x67, 0x87, 0x35, 0xfc, - 0xb2, 0xb6, 0xb4, 0x3f, 0x45, 0xf0, 0xb8, 0x38, 0xed, 0x7c, 0xb3, 0xa9, 0x0e, 0xe4, 0xff, 0x04, - 0xfc, 0x45, 0x80, 0x30, 0xb5, 0x82, 0x41, 0xa6, 0x78, 0x36, 0x86, 0x43, 0x0a, 0xa9, 0xd1, 0x5c, - 0x26, 0x75, 0x2d, 0x56, 0x39, 0xe2, 0x19, 0xa1, 0xfb, 0x23, 0x82, 0xc5, 0x51, 0x84, 0x8a, 0x73, - 0x13, 0x66, 0x15, 0x93, 0x3e, 0xc6, 0x87, 0x12, 0x49, 0x97, 0x9e, 0xbb, 0xfb, 0x6b, 0x2e, 0xf5, - 0xd5, 0x6f, 0xb9, 0x7c, 0xbd, 0x11, 0x5c, 0xed, 0x56, 0x9d, 0x1a, 0x6b, 0xa9, 0xa4, 0xab, 0xff, - 0x36, 0xb9, 0xb7, 0xe7, 0x06, 0xbd, 0x36, 0xe5, 0xc2, 0x81, 0xdf, 0xf9, 0xf3, 0xdb, 0x75, 0x54, - 0x1e, 0x44, 0xc0, 0xaf, 0x1a, 0xc8, 0xad, 0x1e, 0x49, 0x4e, 0x42, 0x8d, 0xb2, 0xb3, 0x3f, 0x47, - 0xb0, 0x22, 0x38, 0xed, 0xb6, 0xa9, 0xef, 0x91, 0x6a, 0x93, 0xfe, 0x37, 0xb5, 0xff, 0x05, 0x41, - 0x76, 0x1c, 0xce, 0xff, 0x77, 0x06, 0xf6, 0x54, 0xd9, 0xbf, 0xc9, 0x02, 0xd2, 0xdc, 0xed, 0xb6, - 0xdb, 0xcd, 0x9e, 0x96, 0x3e, 0x2e, 0x23, 0x9a, 0x82, 0x8c, 0x3f, 0xe8, 0x12, 0x8e, 0x45, 0x53, - 0x02, 0x5e, 0x85, 0x34, 0x17, 0x2b, 0xff, 0x9a, 0x7c, 0xea, 0xfc, 0xe9, 0x89, 0xb7, 0xa1, 0x5e, - 0x20, 0xc9, 0xe4, 0xd2, 0xdb, 0x5a, 0xb9, 0xc1, 0xcb, 0x85, 0x22, 0x2f, 0x97, 0x7d, 0x05, 0x1e, - 0x1d, 0xb2, 0x56, 0xcc, 0x5f, 0x82, 0x34, 0x69, 0xb1, 0xae, 0x1f, 0x1c, 0xf9, 0x5e, 0x95, 0xe6, - 0xfa, 0xcc, 0x15, 0x1b, 0xe9, 0x63, 0x2f, 0x00, 0x16, 0xc7, 0x5e, 0x26, 0x1d, 0xd2, 0xd2, 0xf7, - 0xc6, 0xbe, 0xa2, 0xde, 0x61, 0xbd, 0xaa, 0x42, 0x6d, 0x43, 0xba, 0x2d, 0x56, 0x54, 0xa8, 0x65, - 0xc7, 0xd0, 0xaf, 0x1c, 0xe9, 0x14, 0x0b, 0x26, 0xbd, 0x6c, 0x0f, 0x2c, 0x71, 0xec, 0x85, 0x3e, - 0x23, 0xfe, 0x3a, 0x0d, 0x88, 0x47, 0x02, 0x32, 0xe5, 0x8a, 0xb1, 0xbf, 0x41, 0xb0, 0x6c, 0x0c, - 0xa3, 0x58, 0x5c, 0x84, 0xb9, 0x96, 0x5a, 0xd3, 0x97, 0x6d, 0xc5, 0x48, 0x44, 0x7b, 0x46, 0xa9, - 0x84, 0xae, 0xd3, 0x2b, 0x84, 0x02, 0x2c, 0x85, 0x78, 0x87, 0x55, 0x31, 0x57, 0x43, 0x35, 0xaa, - 0xe4, 0x08, 0xc3, 0x0b, 0x30, 0xab, 0x61, 0x2a, 0x1d, 0x27, 0x27, 0x38, 0xf0, 0xb4, 0xaf, 0xab, - 0xcb, 0x2d, 0x62, 0x5c, 0xba, 0xee, 0xd3, 0x0e, 0x4f, 0x04, 0x35, 0xad, 0x97, 0xd3, 0x7e, 0x0f, - 0x01, 0x84, 0x41, 0x8f, 0xf5, 0x88, 0x6f, 0x87, 0x5d, 0xfc, 0xc4, 0x03, 0xdc, 0x8a, 0x41, 0x43, - 0xff, 0x52, 0xbf, 0x35, 0x31, 0xf2, 0x4a, 0xde, 0x12, 0xcc, 0x0b, 0xc2, 0x15, 0x26, 0xd6, 0x55, - 0x0d, 0xe5, 0x8c, 0x12, 0x87, 0xfe, 0xe5, 0x8c, 0x17, 0x9e, 0x35, 0xbd, 0xe2, 0xe9, 0xa9, 0x2c, - 0xed, 0x52, 0xdf, 0x7b, 0xc5, 0xef, 0x37, 0x17, 0x4f, 0x67, 0xe9, 0x31, 0x48, 0x8b, 0x90, 0x12, - 0xe1, 0x5c, 0x59, 0x7d, 0x1b, 0xca, 0x53, 0xed, 0xd8, 0x79, 0xba, 0xa3, 0x45, 0x8a, 0xc5, 0x56, - 0x22, 0xed, 0xc0, 0x3c, 0xa7, 0xbe, 0x57, 0xa1, 0x72, 0x5d, 0x89, 0x74, 0xc6, 0x28, 0x52, 0xd4, - 0x3f, 0xc3, 0xc3, 0x2f, 0x43, 0x2a, 0xd5, 0x8e, 0xad, 0x52, 0xf1, 0xfe, 0x3c, 0x9c, 0x14, 0x50, - 0xf1, 0x27, 0x08, 0x66, 0x54, 0xfb, 0xc5, 0x79, 0x23, 0x1a, 0xc3, 0x04, 0x6a, 0xad, 0x4d, 0x60, - 0x29, 0xc3, 0xda, 0x2f, 0xdf, 0xea, 0x97, 0xd2, 0xfb, 0x3f, 0xff, 0xf1, 0xd1, 0x89, 0x22, 0x3e, - 0xe7, 0x9a, 0x87, 0x67, 0xd9, 0x88, 0xdd, 0x1b, 0xaa, 0x5e, 0x6f, 0xba, 0xd5, 0x5e, 0x45, 0x5e, - 0xa2, 0x7d, 0x04, 0x99, 0xc8, 0x8c, 0x86, 0x37, 0xc6, 0x47, 0x1e, 0x1d, 0x36, 0xad, 0xcd, 0x09, - 0xad, 0x15, 0xd6, 0x67, 0x43, 0xac, 0x6b, 0x78, 0x75, 0x42, 0xac, 0xf8, 0x7b, 0x04, 0xa7, 0x46, - 0x46, 0x19, 0x5c, 0x1c, 0x1f, 0x7a, 0xdc, 0x7c, 0x66, 0x6d, 0x3d, 0x90, 0x8f, 0x02, 0xbd, 0x1d, - 0x82, 0xde, 0xc2, 0x05, 0x23, 0x68, 0xae, 0x9d, 0x2b, 0x06, 0xf8, 0xb7, 0x11, 0x64, 0x22, 0x23, - 0x44, 0x92, 0xc2, 0xa3, 0x73, 0x4d, 0x92, 0xc2, 0x86, 0xb9, 0xc4, 0xce, 0x87, 0x60, 0x57, 0xf0, - 0xb2, 0x19, 0xac, 0x84, 0x71, 0x1b, 0xc1, 0xac, 0x6e, 0xee, 0x38, 0xa1, 0xde, 0x86, 0xc6, 0x05, - 0x6b, 0x7d, 0x12, 0x53, 0x85, 0xa6, 0x10, 0xa2, 0x39, 0x8b, 0x9f, 0x4e, 0x40, 0x13, 0xd6, 0xe3, - 0x07, 0x08, 0xd2, 0xb2, 0xa3, 0xe3, 0xd5, 0xf1, 0x91, 0x62, 0xe3, 0x83, 0x95, 0x3f, 0xda, 0x70, - 0x72, 0x79, 0xe4, 0xec, 0x80, 0xbf, 0x46, 0xf0, 0x70, 0xac, 0xdb, 0x61, 0x67, 0x7c, 0x14, 0x53, - 0x27, 0xb5, 0xdc, 0x89, 0xed, 0x15, 0xb8, 0x17, 0x42, 0x70, 0x0e, 0xde, 0x30, 0x82, 0x93, 0x2f, - 0x6a, 0x45, 0xf7, 0x4c, 0xf7, 0x86, 0x58, 0xb8, 0x89, 0xbf, 0x40, 0xf0, 0x48, 0x7c, 0xfc, 0xc0, - 0x47, 0x85, 0x1f, 0x9e, 0x87, 0xac, 0x73, 0x93, 0x3b, 0x4c, 0x9e, 0xde, 0x21, 0xc0, 0xf8, 0x33, - 0x04, 0x99, 0x48, 0x8f, 0x4b, 0xba, 0x0c, 0xa3, 0x73, 0x40, 0xd2, 0x65, 0x30, 0x34, 0x4e, 0xfb, - 0xf9, 0x10, 0xdf, 0x33, 0x78, 0x6d, 0x3c, 0x3e, 0xd5, 0x58, 0x07, 0x6a, 0x7e, 0x8c, 0x20, 0x13, - 0xe9, 0x11, 0x49, 0x20, 0x47, 0xdb, 0x60, 0x12, 0x48, 0x43, 0xe3, 0xb2, 0x9d, 0x10, 0xe4, 0x53, - 0xf8, 0x49, 0xf3, 0x1d, 0x89, 0x34, 0xb6, 0xd2, 0xce, 0xdd, 0x83, 0x2c, 0xba, 0x77, 0x90, 0x45, - 0xbf, 0x1f, 0x64, 0xd1, 0x87, 0x87, 0xd9, 0xd4, 0xbd, 0xc3, 0x6c, 0xea, 0xfe, 0x61, 0x36, 0xf5, - 0xd6, 0x5a, 0xe2, 0x0f, 0x8c, 0x77, 0xe5, 0x99, 0xe2, 0x77, 0x46, 0x35, 0x2d, 0xfe, 0xfe, 0xb1, - 0xf5, 0x77, 0x00, 0x00, 0x00, 0xff, 0xff, 0xdf, 0x9a, 0xdc, 0xb5, 0x22, 0x12, 0x00, 0x00, + 0x14, 0xf6, 0x04, 0xd5, 0x49, 0x9e, 0x4b, 0xa5, 0x4e, 0x03, 0x4d, 0x36, 0xc4, 0x2e, 0xdb, 0xaa, + 0xf9, 0x41, 0xb2, 0xdb, 0x38, 0x80, 0x68, 0x55, 0x22, 0xd5, 0x29, 0xed, 0x01, 0xa1, 0x16, 0x87, + 0x5e, 0xe0, 0x60, 0xad, 0xbd, 0x83, 0x6b, 0xc5, 0xde, 0x71, 0x3d, 0x6b, 0x8a, 0x55, 0x55, 0x42, + 0x48, 0x48, 0x3d, 0x22, 0xd1, 0x13, 0x12, 0x22, 0x42, 0x02, 0x2a, 0x90, 0x10, 0x42, 0x1c, 0xf9, + 0x03, 0x7a, 0x41, 0x2a, 0x70, 0x28, 0x27, 0x40, 0x09, 0x12, 0xfc, 0x19, 0xc8, 0xf3, 0xc3, 0xbb, + 0x6b, 0x8f, 0x37, 0x9b, 0xd4, 0x95, 0xe8, 0xa5, 0xb5, 0x67, 0xde, 0x9b, 0xf7, 0x7d, 0xef, 0xbd, + 0x99, 0xf7, 0x39, 0x90, 0xab, 0x50, 0xd6, 0xa0, 0xcc, 0x2e, 0x3b, 0xde, 0x96, 0xfd, 0xde, 0x6a, + 0x99, 0xf8, 0xce, 0xaa, 0x7d, 0xa3, 0x4d, 0x5a, 0x1d, 0xab, 0xd9, 0xa2, 0x3e, 0xc5, 0xc7, 0x84, + 0x81, 0xd5, 0x35, 0xb0, 0xa4, 0x81, 0xb1, 0xd4, 0xf3, 0x62, 0x44, 0x58, 0xf7, 0x7c, 0x9b, 0x4e, + 0xb5, 0xe6, 0x39, 0x7e, 0x8d, 0x7a, 0xe2, 0x00, 0x63, 0xaa, 0x4a, 0xab, 0x94, 0x7f, 0xb4, 0xbb, + 0x9f, 0xe4, 0xea, 0x73, 0x55, 0x4a, 0xab, 0x75, 0x62, 0x3b, 0xcd, 0x9a, 0xed, 0x78, 0x1e, 0xf5, + 0xb9, 0x0b, 0x93, 0xbb, 0xd9, 0xf0, 0xf9, 0xea, 0xe4, 0x0a, 0xad, 0x79, 0x03, 0xfb, 0x21, 0xd4, + 0x1c, 0xa1, 0xd8, 0x9f, 0x11, 0xfb, 0x25, 0x11, 0x56, 0x32, 0x10, 0x5b, 0xb3, 0xd2, 0x55, 0xa1, + 0x0e, 0x93, 0x35, 0x8e, 0x3a, 0x8d, 0x9a, 0x47, 0x6d, 0xfe, 0xaf, 0x58, 0x32, 0x6b, 0x70, 0xec, + 0xcd, 0xae, 0x45, 0xc1, 0xa9, 0x3b, 0x5e, 0x85, 0x14, 0xc9, 0x8d, 0x36, 0x61, 0x3e, 0xce, 0xc3, + 0xb8, 0xe3, 0xba, 0x2d, 0xc2, 0xd8, 0x34, 0x3a, 0x81, 0x16, 0x26, 0x0b, 0xd3, 0xbf, 0xfe, 0xb8, + 0x32, 0x25, 0x23, 0x5d, 0x10, 0x3b, 0x9b, 0x7e, 0xab, 0xe6, 0x55, 0x8b, 0xca, 0x10, 0x4f, 0xc1, + 0x21, 0x97, 0x78, 0xb4, 0x31, 0x3d, 0xd6, 0xf5, 0x28, 0x8a, 0x2f, 0xe7, 0x26, 0xee, 0x6c, 0xe7, + 0x52, 0xff, 0x6e, 0xe7, 0x52, 0xe6, 0xeb, 0x30, 0x15, 0x0d, 0xc5, 0x9a, 0xd4, 0x63, 0x04, 0xaf, + 0xc1, 0x78, 0x59, 0x2c, 0xf1, 0x58, 0x99, 0xfc, 0x8c, 0xd5, 0x2b, 0x0a, 0x23, 0xaa, 0x28, 0xd6, + 0x06, 0xad, 0x79, 0x45, 0x65, 0x69, 0x7e, 0x8e, 0xe0, 0x38, 0x3f, 0xed, 0x42, 0xbd, 0x2e, 0x0f, + 0x64, 0x8f, 0x02, 0xfe, 0x12, 0x40, 0x50, 0x5a, 0xce, 0x20, 0x93, 0x3f, 0x1d, 0xc1, 0x21, 0x12, + 0xa9, 0xd0, 0x5c, 0x75, 0xaa, 0x2a, 0x59, 0xc5, 0x90, 0x67, 0x88, 0xee, 0x2f, 0x08, 0xa6, 0x07, + 0x11, 0x4a, 0xce, 0x75, 0x98, 0x90, 0x4c, 0xba, 0x18, 0x9f, 0x8a, 0x25, 0x5d, 0x78, 0xe9, 0xfe, + 0x1f, 0xb9, 0xd4, 0x37, 0x7f, 0xe6, 0x16, 0xaa, 0x35, 0xff, 0x7a, 0xbb, 0x6c, 0x55, 0x68, 0x43, + 0x16, 0x5d, 0xfe, 0xb7, 0xc2, 0xdc, 0x2d, 0xdb, 0xef, 0x34, 0x09, 0xe3, 0x0e, 0xec, 0xde, 0x3f, + 0xdf, 0x2f, 0xa1, 0x62, 0x2f, 0x02, 0xbe, 0xac, 0x21, 0x37, 0xbf, 0x27, 0x39, 0x01, 0x35, 0xcc, + 0xce, 0xfc, 0x12, 0xc1, 0x1c, 0xe7, 0xb4, 0xd9, 0x24, 0x9e, 0xeb, 0x94, 0xeb, 0xe4, 0xff, 0x99, + 0xfb, 0x87, 0x08, 0xb2, 0xc3, 0x70, 0x3e, 0xd9, 0x15, 0xe8, 0xc0, 0x49, 0x2d, 0xb1, 0x42, 0xe7, + 0x62, 0xf7, 0xba, 0x3d, 0xce, 0xfb, 0xfb, 0x0e, 0x9c, 0x8a, 0x0f, 0xfd, 0x28, 0xf7, 0x79, 0x4b, + 0x5e, 0xe7, 0xb7, 0xa8, 0xef, 0xd4, 0x37, 0xdb, 0xcd, 0x66, 0xbd, 0xa3, 0xb8, 0x44, 0xdb, 0x03, + 0x8d, 0xa0, 0x3d, 0x7e, 0x56, 0x57, 0x33, 0x12, 0x4d, 0xc2, 0xbf, 0x0e, 0x69, 0xc6, 0x57, 0x1e, + 0x5b, 0x5b, 0xc8, 0xf3, 0x47, 0xd7, 0x14, 0xcb, 0xf2, 0x65, 0x15, 0x4c, 0xae, 0xbc, 0xab, 0x32, + 0xd7, 0xab, 0x28, 0x0a, 0x55, 0xd4, 0xbc, 0x06, 0xcf, 0xf4, 0x59, 0x4b, 0xe6, 0xe7, 0x21, 0xed, + 0x34, 0x68, 0xdb, 0xf3, 0xf7, 0xac, 0x5b, 0x61, 0xb2, 0xcb, 0x5c, 0xb2, 0x11, 0x3e, 0xe6, 0x14, + 0x60, 0x7e, 0xec, 0x55, 0xa7, 0xe5, 0x34, 0xd4, 0x7b, 0x60, 0x5e, 0x93, 0xf3, 0x45, 0xad, 0xca, + 0x50, 0xeb, 0x90, 0x6e, 0xf2, 0x15, 0x19, 0x6a, 0xd6, 0xd2, 0xcc, 0x61, 0x4b, 0x38, 0x45, 0x82, + 0x09, 0x2f, 0xd3, 0x05, 0x83, 0x1f, 0xcb, 0x3b, 0x8f, 0xbd, 0x41, 0x7c, 0xc7, 0x75, 0x7c, 0x67, + 0xc4, 0x1d, 0x63, 0x7e, 0x87, 0x60, 0x56, 0x1b, 0x46, 0xb2, 0xb8, 0x04, 0x93, 0x0d, 0xb9, 0xa6, + 0x1e, 0x91, 0x39, 0x2d, 0x11, 0xe5, 0x19, 0xa6, 0x12, 0xb8, 0x8e, 0xae, 0x11, 0x56, 0x61, 0x26, + 0xc0, 0xdb, 0x9f, 0x15, 0x7d, 0x37, 0x94, 0xc3, 0x99, 0x1c, 0x60, 0x78, 0x11, 0x26, 0x14, 0x4c, + 0x99, 0xc7, 0xe4, 0x04, 0x7b, 0x9e, 0xe6, 0x4d, 0x79, 0xb9, 0x79, 0x8c, 0x2b, 0x37, 0x3d, 0xd2, + 0x62, 0xb1, 0xa0, 0x46, 0x35, 0x11, 0xcc, 0x0f, 0x10, 0x40, 0x10, 0xf4, 0x40, 0xaf, 0xe2, 0x7a, + 0xf0, 0x9a, 0x8d, 0xed, 0xe3, 0x56, 0xf4, 0x1e, 0xb6, 0xaf, 0xd5, 0x5b, 0x13, 0x21, 0x2f, 0xd3, + 0x5b, 0x80, 0xc3, 0x9c, 0x70, 0x89, 0xf2, 0x75, 0xd9, 0x43, 0x39, 0x6d, 0x8a, 0x03, 0xff, 0x62, + 0xc6, 0x0d, 0xce, 0x1a, 0xe5, 0x68, 0x11, 0x55, 0xda, 0x24, 0x9e, 0xfb, 0x9a, 0xd7, 0x7d, 0xe0, + 0x5d, 0x55, 0xa5, 0x67, 0x21, 0xcd, 0x43, 0x0a, 0x84, 0x93, 0x45, 0xf9, 0xad, 0xaf, 0x4e, 0x95, + 0x03, 0xd7, 0xe9, 0x9e, 0x4a, 0x52, 0x24, 0xb6, 0x4c, 0xd2, 0x06, 0x1c, 0x66, 0xc4, 0x73, 0x4b, + 0x44, 0xac, 0xcb, 0x24, 0x9d, 0xd0, 0x26, 0x29, 0xec, 0x9f, 0x61, 0xc1, 0x97, 0xbe, 0x2c, 0x55, + 0x0e, 0x9c, 0xa5, 0xfc, 0x0f, 0x47, 0xe0, 0x10, 0x87, 0x8a, 0x3f, 0x43, 0x30, 0x2e, 0x47, 0x20, + 0x5e, 0xd0, 0xa2, 0xd1, 0x28, 0x6b, 0x63, 0x31, 0x81, 0xa5, 0x08, 0x6b, 0xbe, 0x7a, 0xa7, 0xdb, + 0x4a, 0x1f, 0xfe, 0xf6, 0xf7, 0x27, 0x63, 0x79, 0x7c, 0xc6, 0xd6, 0xff, 0x28, 0x10, 0x02, 0xc3, + 0xbe, 0x25, 0xfb, 0xf5, 0xb6, 0x5d, 0xee, 0x94, 0xc4, 0x25, 0xda, 0x46, 0x90, 0x09, 0x69, 0x4f, + 0xbc, 0x3c, 0x3c, 0xf2, 0xa0, 0x88, 0x36, 0x56, 0x12, 0x5a, 0x4b, 0xac, 0x2f, 0x06, 0x58, 0x17, + 0xf1, 0x7c, 0x42, 0xac, 0xf8, 0x27, 0x04, 0x47, 0x07, 0x24, 0x1a, 0xce, 0x0f, 0x0f, 0x3d, 0x4c, + 0x77, 0x1a, 0x6b, 0xfb, 0xf2, 0x91, 0xa0, 0xd7, 0x03, 0xd0, 0x6b, 0x78, 0x55, 0x0b, 0x9a, 0x29, + 0xe7, 0x92, 0x06, 0xfe, 0x43, 0x04, 0xc7, 0x87, 0xa8, 0x21, 0xfc, 0x4a, 0x72, 0x40, 0x51, 0xed, + 0x66, 0x9c, 0x3d, 0x80, 0xa7, 0x24, 0x74, 0x39, 0x20, 0x74, 0x1e, 0x9f, 0xdb, 0x37, 0xa1, 0xa0, + 0x77, 0xee, 0x22, 0xc8, 0x84, 0xc4, 0x51, 0x5c, 0xef, 0x0c, 0x2a, 0xb6, 0xb8, 0xde, 0xd1, 0x28, + 0x2e, 0x73, 0x21, 0x40, 0x3d, 0x87, 0x67, 0xf5, 0xa8, 0x05, 0x8c, 0xbb, 0x08, 0x26, 0x94, 0x6c, + 0xc1, 0x31, 0x37, 0xa9, 0x4f, 0x08, 0x19, 0x4b, 0x49, 0x4c, 0x25, 0x9a, 0xd5, 0x00, 0xcd, 0x69, + 0x7c, 0x2a, 0x06, 0x4d, 0x90, 0xad, 0x8f, 0x10, 0xa4, 0x85, 0x56, 0xc1, 0xf3, 0xc3, 0x23, 0x45, + 0x84, 0x91, 0xb1, 0xb0, 0xb7, 0x61, 0xf2, 0xf4, 0x08, 0x55, 0x84, 0xbf, 0x45, 0xf0, 0x74, 0x64, + 0x8e, 0x63, 0x6b, 0x78, 0x14, 0x9d, 0x46, 0x30, 0xec, 0xc4, 0xf6, 0x12, 0xdc, 0xd9, 0x00, 0x9c, + 0x85, 0x97, 0xb5, 0xe0, 0xc4, 0xac, 0x28, 0x29, 0x35, 0x60, 0xdf, 0xe2, 0x0b, 0xb7, 0xf1, 0x57, + 0x08, 0x8e, 0x44, 0x85, 0x15, 0xde, 0x2b, 0x7c, 0xbf, 0xd2, 0x33, 0xce, 0x24, 0x77, 0x48, 0x5e, + 0xde, 0x3e, 0xc0, 0xf8, 0x0b, 0x04, 0x99, 0xd0, 0xf4, 0x8e, 0xbb, 0x0c, 0x83, 0x0a, 0x27, 0xee, + 0x32, 0x68, 0x24, 0x81, 0xf9, 0x72, 0x80, 0xef, 0x05, 0xbc, 0x38, 0x1c, 0x9f, 0x94, 0x0c, 0xbd, + 0x6c, 0x7e, 0x8a, 0x20, 0x13, 0x9a, 0x7e, 0x71, 0x20, 0x07, 0x07, 0x7c, 0x1c, 0x48, 0xcd, 0x48, + 0x36, 0xad, 0x00, 0xe4, 0x49, 0xfc, 0xbc, 0xfe, 0x8e, 0x84, 0x46, 0x76, 0x61, 0xe3, 0xfe, 0x4e, + 0x16, 0x3d, 0xd8, 0xc9, 0xa2, 0xbf, 0x76, 0xb2, 0xe8, 0xe3, 0xdd, 0x6c, 0xea, 0xc1, 0x6e, 0x36, + 0xf5, 0xfb, 0x6e, 0x36, 0xf5, 0xf6, 0x62, 0xec, 0x4f, 0xa7, 0xf7, 0xc5, 0x99, 0xfc, 0x17, 0x54, + 0x39, 0xcd, 0xff, 0x62, 0xb5, 0xf6, 0x5f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xf4, 0x2c, 0x27, 0x2a, + 0xd4, 0x13, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -1196,7 +1295,7 @@ type QueryClient interface { // When called from another module, this query might consume a high amount of // gas if the pagination field is incorrectly set. AllBalances(ctx context.Context, in *QueryAllBalancesRequest, opts ...grpc.CallOption) (*QueryAllBalancesResponse, error) - // SpendableBalances queries the spenable balance of all coins for a single + // SpendableBalances queries the spendable balance of all coins for a single // account. // // When called from another module, this query might consume a high amount of @@ -1204,6 +1303,14 @@ type QueryClient interface { // // Since: cosmos-sdk 0.46 SpendableBalances(ctx context.Context, in *QuerySpendableBalancesRequest, opts ...grpc.CallOption) (*QuerySpendableBalancesResponse, error) + // SpendableBalanceByDenom queries the spendable balance of a single denom for + // a single account. + // + // When called from another module, this query might consume a high amount of + // gas if the pagination field is incorrectly set. + // + // Since: cosmos-sdk 0.47 + SpendableBalanceByDenom(ctx context.Context, in *QuerySpendableBalanceByDenomRequest, opts ...grpc.CallOption) (*QuerySpendableBalanceByDenomResponse, error) // TotalSupply queries the total supply of all coins. // // When called from another module, this query might consume a high amount of @@ -1274,6 +1381,15 @@ func (c *queryClient) SpendableBalances(ctx context.Context, in *QuerySpendableB return out, nil } +func (c *queryClient) SpendableBalanceByDenom(ctx context.Context, in *QuerySpendableBalanceByDenomRequest, opts ...grpc.CallOption) (*QuerySpendableBalanceByDenomResponse, error) { + out := new(QuerySpendableBalanceByDenomResponse) + err := c.cc.Invoke(ctx, "/cosmos.bank.v1beta1.Query/SpendableBalanceByDenom", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *queryClient) TotalSupply(ctx context.Context, in *QueryTotalSupplyRequest, opts ...grpc.CallOption) (*QueryTotalSupplyResponse, error) { out := new(QueryTotalSupplyResponse) err := c.cc.Invoke(ctx, "/cosmos.bank.v1beta1.Query/TotalSupply", in, out, opts...) @@ -1346,7 +1462,7 @@ type QueryServer interface { // When called from another module, this query might consume a high amount of // gas if the pagination field is incorrectly set. AllBalances(context.Context, *QueryAllBalancesRequest) (*QueryAllBalancesResponse, error) - // SpendableBalances queries the spenable balance of all coins for a single + // SpendableBalances queries the spendable balance of all coins for a single // account. // // When called from another module, this query might consume a high amount of @@ -1354,6 +1470,14 @@ type QueryServer interface { // // Since: cosmos-sdk 0.46 SpendableBalances(context.Context, *QuerySpendableBalancesRequest) (*QuerySpendableBalancesResponse, error) + // SpendableBalanceByDenom queries the spendable balance of a single denom for + // a single account. + // + // When called from another module, this query might consume a high amount of + // gas if the pagination field is incorrectly set. + // + // Since: cosmos-sdk 0.47 + SpendableBalanceByDenom(context.Context, *QuerySpendableBalanceByDenomRequest) (*QuerySpendableBalanceByDenomResponse, error) // TotalSupply queries the total supply of all coins. // // When called from another module, this query might consume a high amount of @@ -1402,6 +1526,9 @@ func (*UnimplementedQueryServer) AllBalances(ctx context.Context, req *QueryAllB func (*UnimplementedQueryServer) SpendableBalances(ctx context.Context, req *QuerySpendableBalancesRequest) (*QuerySpendableBalancesResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method SpendableBalances not implemented") } +func (*UnimplementedQueryServer) SpendableBalanceByDenom(ctx context.Context, req *QuerySpendableBalanceByDenomRequest) (*QuerySpendableBalanceByDenomResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method SpendableBalanceByDenom not implemented") +} func (*UnimplementedQueryServer) TotalSupply(ctx context.Context, req *QueryTotalSupplyRequest) (*QueryTotalSupplyResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method TotalSupply not implemented") } @@ -1482,6 +1609,24 @@ func _Query_SpendableBalances_Handler(srv interface{}, ctx context.Context, dec return interceptor(ctx, in, info, handler) } +func _Query_SpendableBalanceByDenom_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QuerySpendableBalanceByDenomRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).SpendableBalanceByDenom(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmos.bank.v1beta1.Query/SpendableBalanceByDenom", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).SpendableBalanceByDenom(ctx, req.(*QuerySpendableBalanceByDenomRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _Query_TotalSupply_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(QueryTotalSupplyRequest) if err := dec(in); err != nil { @@ -1624,6 +1769,10 @@ var _Query_serviceDesc = grpc.ServiceDesc{ MethodName: "SpendableBalances", Handler: _Query_SpendableBalances_Handler, }, + { + MethodName: "SpendableBalanceByDenom", + Handler: _Query_SpendableBalanceByDenom_Handler, + }, { MethodName: "TotalSupply", Handler: _Query_TotalSupply_Handler, @@ -1911,6 +2060,78 @@ func (m *QuerySpendableBalancesResponse) MarshalToSizedBuffer(dAtA []byte) (int, return len(dAtA) - i, nil } +func (m *QuerySpendableBalanceByDenomRequest) 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 *QuerySpendableBalanceByDenomRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QuerySpendableBalanceByDenomRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Denom) > 0 { + i -= len(m.Denom) + copy(dAtA[i:], m.Denom) + i = encodeVarintQuery(dAtA, i, uint64(len(m.Denom))) + i-- + dAtA[i] = 0x12 + } + if len(m.Address) > 0 { + i -= len(m.Address) + copy(dAtA[i:], m.Address) + i = encodeVarintQuery(dAtA, i, uint64(len(m.Address))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QuerySpendableBalanceByDenomResponse) 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 *QuerySpendableBalanceByDenomResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QuerySpendableBalanceByDenomResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Balance != nil { + { + size, err := m.Balance.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 *QueryTotalSupplyRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -2602,6 +2823,36 @@ func (m *QuerySpendableBalancesResponse) Size() (n int) { return n } +func (m *QuerySpendableBalanceByDenomRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Address) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + l = len(m.Denom) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QuerySpendableBalanceByDenomResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Balance != nil { + l = m.Balance.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + func (m *QueryTotalSupplyRequest) Size() (n int) { if m == nil { return 0 @@ -3505,6 +3756,206 @@ func (m *QuerySpendableBalancesResponse) Unmarshal(dAtA []byte) error { } return nil } +func (m *QuerySpendableBalanceByDenomRequest) 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: QuerySpendableBalanceByDenomRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QuerySpendableBalanceByDenomRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Address", 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.Address = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Denom", 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.Denom = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QuerySpendableBalanceByDenomResponse) 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: QuerySpendableBalanceByDenomResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QuerySpendableBalanceByDenomResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + 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 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.Balance == nil { + m.Balance = &types.Coin{} + } + if err := m.Balance.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func (m *QueryTotalSupplyRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 diff --git a/x/bank/types/query.pb.gw.go b/x/bank/types/query.pb.gw.go index eafa8bdd44e2..982f53168300 100644 --- a/x/bank/types/query.pb.gw.go +++ b/x/bank/types/query.pb.gw.go @@ -249,6 +249,78 @@ func local_request_Query_SpendableBalances_0(ctx context.Context, marshaler runt } +var ( + filter_Query_SpendableBalanceByDenom_0 = &utilities.DoubleArray{Encoding: map[string]int{"address": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}} +) + +func request_Query_SpendableBalanceByDenom_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QuerySpendableBalanceByDenomRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["address"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "address") + } + + protoReq.Address, err = runtime.String(val) + + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "address", err) + } + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_SpendableBalanceByDenom_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.SpendableBalanceByDenom(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_SpendableBalanceByDenom_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QuerySpendableBalanceByDenomRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["address"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "address") + } + + protoReq.Address, err = runtime.String(val) + + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "address", err) + } + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_SpendableBalanceByDenom_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.SpendableBalanceByDenom(ctx, &protoReq) + return msg, metadata, err + +} + var ( filter_Query_TotalSupply_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} ) @@ -612,6 +684,29 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv }) + mux.Handle("GET", pattern_Query_SpendableBalanceByDenom_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_Query_SpendableBalanceByDenom_0(rctx, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_SpendableBalanceByDenom_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + mux.Handle("GET", pattern_Query_TotalSupply_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() @@ -874,6 +969,26 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie }) + mux.Handle("GET", pattern_Query_SpendableBalanceByDenom_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_Query_SpendableBalanceByDenom_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_SpendableBalanceByDenom_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + mux.Handle("GET", pattern_Query_TotalSupply_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() @@ -1024,6 +1139,8 @@ var ( pattern_Query_SpendableBalances_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"cosmos", "bank", "v1beta1", "spendable_balances", "address"}, "", runtime.AssumeColonVerbOpt(false))) + pattern_Query_SpendableBalanceByDenom_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 2, 5}, []string{"cosmos", "bank", "v1beta1", "spendable_balances", "address", "by_denom"}, "", runtime.AssumeColonVerbOpt(false))) + pattern_Query_TotalSupply_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"cosmos", "bank", "v1beta1", "supply"}, "", runtime.AssumeColonVerbOpt(false))) pattern_Query_SupplyOf_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"cosmos", "bank", "v1beta1", "supply", "by_denom"}, "", runtime.AssumeColonVerbOpt(false))) @@ -1046,6 +1163,8 @@ var ( forward_Query_SpendableBalances_0 = runtime.ForwardResponseMessage + forward_Query_SpendableBalanceByDenom_0 = runtime.ForwardResponseMessage + forward_Query_TotalSupply_0 = runtime.ForwardResponseMessage forward_Query_SupplyOf_0 = runtime.ForwardResponseMessage diff --git a/x/gov/testutil/expected_keepers_mocks.go b/x/gov/testutil/expected_keepers_mocks.go index e119ee2bf6e9..d6ea88c1b679 100644 --- a/x/gov/testutil/expected_keepers_mocks.go +++ b/x/gov/testutil/expected_keepers_mocks.go @@ -789,6 +789,21 @@ func (mr *MockBankKeeperMockRecorder) SetSendEnabled(ctx, denom, value interface return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSendEnabled", reflect.TypeOf((*MockBankKeeper)(nil).SetSendEnabled), ctx, denom, value) } +// SpendableBalanceByDenom mocks base method. +func (m *MockBankKeeper) SpendableBalanceByDenom(arg0 context.Context, arg1 *types1.QuerySpendableBalanceByDenomRequest) (*types1.QuerySpendableBalanceByDenomResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SpendableBalanceByDenom", arg0, arg1) + ret0, _ := ret[0].(*types1.QuerySpendableBalanceByDenomResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SpendableBalanceByDenom indicates an expected call of SpendableBalanceByDenom. +func (mr *MockBankKeeperMockRecorder) SpendableBalanceByDenom(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpendableBalanceByDenom", reflect.TypeOf((*MockBankKeeper)(nil).SpendableBalanceByDenom), arg0, arg1) +} + // SpendableBalances mocks base method. func (m *MockBankKeeper) SpendableBalances(arg0 context.Context, arg1 *types1.QuerySpendableBalancesRequest) (*types1.QuerySpendableBalancesResponse, error) { m.ctrl.T.Helper() From 3b17966ed025ad12e21f68ff6f8600bd85945de4 Mon Sep 17 00:00:00 2001 From: Facundo Medica Date: Tue, 20 Dec 2022 15:47:24 -0300 Subject: [PATCH 6/8] remove since annotations --- api/cosmos/bank/v1beta1/query.pulsar.go | 4 ---- api/cosmos/bank/v1beta1/query_grpc.pb.go | 4 ---- proto/cosmos/bank/v1beta1/query.proto | 6 ------ x/bank/types/query.pb.go | 8 -------- 4 files changed, 22 deletions(-) diff --git a/api/cosmos/bank/v1beta1/query.pulsar.go b/api/cosmos/bank/v1beta1/query.pulsar.go index ae6bebdff958..5d233f68abff 100644 --- a/api/cosmos/bank/v1beta1/query.pulsar.go +++ b/api/cosmos/bank/v1beta1/query.pulsar.go @@ -11514,8 +11514,6 @@ func (x *QuerySpendableBalancesResponse) GetPagination() *v1beta11.PageResponse // QuerySpendableBalanceByDenomRequest defines the gRPC request structure for // querying an account's spendable balance for a specific denom. -// -// Since: cosmos-sdk 0.47 type QuerySpendableBalanceByDenomRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache @@ -11563,8 +11561,6 @@ func (x *QuerySpendableBalanceByDenomRequest) GetDenom() string { // QuerySpendableBalanceByDenomResponse defines the gRPC response structure for // querying an account's spendable balance for a specific denom. -// -// Since: cosmos-sdk 0.47 type QuerySpendableBalanceByDenomResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache diff --git a/api/cosmos/bank/v1beta1/query_grpc.pb.go b/api/cosmos/bank/v1beta1/query_grpc.pb.go index 1814a7da9eb5..9e12450187a9 100644 --- a/api/cosmos/bank/v1beta1/query_grpc.pb.go +++ b/api/cosmos/bank/v1beta1/query_grpc.pb.go @@ -42,8 +42,6 @@ type QueryClient interface { // // When called from another module, this query might consume a high amount of // gas if the pagination field is incorrectly set. - // - // Since: cosmos-sdk 0.47 SpendableBalanceByDenom(ctx context.Context, in *QuerySpendableBalanceByDenomRequest, opts ...grpc.CallOption) (*QuerySpendableBalanceByDenomResponse, error) // TotalSupply queries the total supply of all coins. // @@ -211,8 +209,6 @@ type QueryServer interface { // // When called from another module, this query might consume a high amount of // gas if the pagination field is incorrectly set. - // - // Since: cosmos-sdk 0.47 SpendableBalanceByDenom(context.Context, *QuerySpendableBalanceByDenomRequest) (*QuerySpendableBalanceByDenomResponse, error) // TotalSupply queries the total supply of all coins. // diff --git a/proto/cosmos/bank/v1beta1/query.proto b/proto/cosmos/bank/v1beta1/query.proto index 7abc31bacbf1..671c2726b0cd 100644 --- a/proto/cosmos/bank/v1beta1/query.proto +++ b/proto/cosmos/bank/v1beta1/query.proto @@ -46,8 +46,6 @@ service Query { // // When called from another module, this query might consume a high amount of // gas if the pagination field is incorrectly set. - // - // Since: cosmos-sdk 0.47 rpc SpendableBalanceByDenom(QuerySpendableBalanceByDenomRequest) returns (QuerySpendableBalanceByDenomResponse) { option (cosmos.query.v1.module_query_safe) = true; option (google.api.http).get = "/cosmos/bank/v1beta1/spendable_balances/{address}/by_denom"; @@ -192,8 +190,6 @@ message QuerySpendableBalancesResponse { // QuerySpendableBalanceByDenomRequest defines the gRPC request structure for // querying an account's spendable balance for a specific denom. -// -// Since: cosmos-sdk 0.47 message QuerySpendableBalanceByDenomRequest { option (gogoproto.equal) = false; option (gogoproto.goproto_getters) = false; @@ -207,8 +203,6 @@ message QuerySpendableBalanceByDenomRequest { // QuerySpendableBalanceByDenomResponse defines the gRPC response structure for // querying an account's spendable balance for a specific denom. -// -// Since: cosmos-sdk 0.47 message QuerySpendableBalanceByDenomResponse { // balance is the balance of the coin. cosmos.base.v1beta1.Coin balance = 1; diff --git a/x/bank/types/query.pb.go b/x/bank/types/query.pb.go index 7f8c6931b6c9..93652cadf4f3 100644 --- a/x/bank/types/query.pb.go +++ b/x/bank/types/query.pb.go @@ -322,8 +322,6 @@ func (m *QuerySpendableBalancesResponse) GetPagination() *query.PageResponse { // QuerySpendableBalanceByDenomRequest defines the gRPC request structure for // querying an account's spendable balance for a specific denom. -// -// Since: cosmos-sdk 0.47 type QuerySpendableBalanceByDenomRequest struct { // address is the address to query balances for. Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` @@ -366,8 +364,6 @@ var xxx_messageInfo_QuerySpendableBalanceByDenomRequest proto.InternalMessageInf // QuerySpendableBalanceByDenomResponse defines the gRPC response structure for // querying an account's spendable balance for a specific denom. -// -// Since: cosmos-sdk 0.47 type QuerySpendableBalanceByDenomResponse struct { // balance is the balance of the coin. Balance *types.Coin `protobuf:"bytes,1,opt,name=balance,proto3" json:"balance,omitempty"` @@ -1308,8 +1304,6 @@ type QueryClient interface { // // When called from another module, this query might consume a high amount of // gas if the pagination field is incorrectly set. - // - // Since: cosmos-sdk 0.47 SpendableBalanceByDenom(ctx context.Context, in *QuerySpendableBalanceByDenomRequest, opts ...grpc.CallOption) (*QuerySpendableBalanceByDenomResponse, error) // TotalSupply queries the total supply of all coins. // @@ -1475,8 +1469,6 @@ type QueryServer interface { // // When called from another module, this query might consume a high amount of // gas if the pagination field is incorrectly set. - // - // Since: cosmos-sdk 0.47 SpendableBalanceByDenom(context.Context, *QuerySpendableBalanceByDenomRequest) (*QuerySpendableBalanceByDenomResponse, error) // TotalSupply queries the total supply of all coins. // From 91428ba359eef77d6481b9e7466be90a537eb631 Mon Sep 17 00:00:00 2001 From: Facundo Medica Date: Thu, 22 Dec 2022 12:09:13 -0300 Subject: [PATCH 7/8] Revert "remove since annotations" This reverts commit 3b17966ed025ad12e21f68ff6f8600bd85945de4. --- api/cosmos/bank/v1beta1/query.pulsar.go | 4 ++++ api/cosmos/bank/v1beta1/query_grpc.pb.go | 4 ++++ proto/cosmos/bank/v1beta1/query.proto | 6 ++++++ x/bank/types/query.pb.go | 8 ++++++++ 4 files changed, 22 insertions(+) diff --git a/api/cosmos/bank/v1beta1/query.pulsar.go b/api/cosmos/bank/v1beta1/query.pulsar.go index 5d233f68abff..ae6bebdff958 100644 --- a/api/cosmos/bank/v1beta1/query.pulsar.go +++ b/api/cosmos/bank/v1beta1/query.pulsar.go @@ -11514,6 +11514,8 @@ func (x *QuerySpendableBalancesResponse) GetPagination() *v1beta11.PageResponse // QuerySpendableBalanceByDenomRequest defines the gRPC request structure for // querying an account's spendable balance for a specific denom. +// +// Since: cosmos-sdk 0.47 type QuerySpendableBalanceByDenomRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache @@ -11561,6 +11563,8 @@ func (x *QuerySpendableBalanceByDenomRequest) GetDenom() string { // QuerySpendableBalanceByDenomResponse defines the gRPC response structure for // querying an account's spendable balance for a specific denom. +// +// Since: cosmos-sdk 0.47 type QuerySpendableBalanceByDenomResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache diff --git a/api/cosmos/bank/v1beta1/query_grpc.pb.go b/api/cosmos/bank/v1beta1/query_grpc.pb.go index 9e12450187a9..1814a7da9eb5 100644 --- a/api/cosmos/bank/v1beta1/query_grpc.pb.go +++ b/api/cosmos/bank/v1beta1/query_grpc.pb.go @@ -42,6 +42,8 @@ type QueryClient interface { // // When called from another module, this query might consume a high amount of // gas if the pagination field is incorrectly set. + // + // Since: cosmos-sdk 0.47 SpendableBalanceByDenom(ctx context.Context, in *QuerySpendableBalanceByDenomRequest, opts ...grpc.CallOption) (*QuerySpendableBalanceByDenomResponse, error) // TotalSupply queries the total supply of all coins. // @@ -209,6 +211,8 @@ type QueryServer interface { // // When called from another module, this query might consume a high amount of // gas if the pagination field is incorrectly set. + // + // Since: cosmos-sdk 0.47 SpendableBalanceByDenom(context.Context, *QuerySpendableBalanceByDenomRequest) (*QuerySpendableBalanceByDenomResponse, error) // TotalSupply queries the total supply of all coins. // diff --git a/proto/cosmos/bank/v1beta1/query.proto b/proto/cosmos/bank/v1beta1/query.proto index 671c2726b0cd..7abc31bacbf1 100644 --- a/proto/cosmos/bank/v1beta1/query.proto +++ b/proto/cosmos/bank/v1beta1/query.proto @@ -46,6 +46,8 @@ service Query { // // When called from another module, this query might consume a high amount of // gas if the pagination field is incorrectly set. + // + // Since: cosmos-sdk 0.47 rpc SpendableBalanceByDenom(QuerySpendableBalanceByDenomRequest) returns (QuerySpendableBalanceByDenomResponse) { option (cosmos.query.v1.module_query_safe) = true; option (google.api.http).get = "/cosmos/bank/v1beta1/spendable_balances/{address}/by_denom"; @@ -190,6 +192,8 @@ message QuerySpendableBalancesResponse { // QuerySpendableBalanceByDenomRequest defines the gRPC request structure for // querying an account's spendable balance for a specific denom. +// +// Since: cosmos-sdk 0.47 message QuerySpendableBalanceByDenomRequest { option (gogoproto.equal) = false; option (gogoproto.goproto_getters) = false; @@ -203,6 +207,8 @@ message QuerySpendableBalanceByDenomRequest { // QuerySpendableBalanceByDenomResponse defines the gRPC response structure for // querying an account's spendable balance for a specific denom. +// +// Since: cosmos-sdk 0.47 message QuerySpendableBalanceByDenomResponse { // balance is the balance of the coin. cosmos.base.v1beta1.Coin balance = 1; diff --git a/x/bank/types/query.pb.go b/x/bank/types/query.pb.go index 93652cadf4f3..7f8c6931b6c9 100644 --- a/x/bank/types/query.pb.go +++ b/x/bank/types/query.pb.go @@ -322,6 +322,8 @@ func (m *QuerySpendableBalancesResponse) GetPagination() *query.PageResponse { // QuerySpendableBalanceByDenomRequest defines the gRPC request structure for // querying an account's spendable balance for a specific denom. +// +// Since: cosmos-sdk 0.47 type QuerySpendableBalanceByDenomRequest struct { // address is the address to query balances for. Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` @@ -364,6 +366,8 @@ var xxx_messageInfo_QuerySpendableBalanceByDenomRequest proto.InternalMessageInf // QuerySpendableBalanceByDenomResponse defines the gRPC response structure for // querying an account's spendable balance for a specific denom. +// +// Since: cosmos-sdk 0.47 type QuerySpendableBalanceByDenomResponse struct { // balance is the balance of the coin. Balance *types.Coin `protobuf:"bytes,1,opt,name=balance,proto3" json:"balance,omitempty"` @@ -1304,6 +1308,8 @@ type QueryClient interface { // // When called from another module, this query might consume a high amount of // gas if the pagination field is incorrectly set. + // + // Since: cosmos-sdk 0.47 SpendableBalanceByDenom(ctx context.Context, in *QuerySpendableBalanceByDenomRequest, opts ...grpc.CallOption) (*QuerySpendableBalanceByDenomResponse, error) // TotalSupply queries the total supply of all coins. // @@ -1469,6 +1475,8 @@ type QueryServer interface { // // When called from another module, this query might consume a high amount of // gas if the pagination field is incorrectly set. + // + // Since: cosmos-sdk 0.47 SpendableBalanceByDenom(context.Context, *QuerySpendableBalanceByDenomRequest) (*QuerySpendableBalanceByDenomResponse, error) // TotalSupply queries the total supply of all coins. // From f908c6cea00c86cea1063687fdf013f398790506 Mon Sep 17 00:00:00 2001 From: Facundo Medica Date: Thu, 5 Jan 2023 15:00:31 -0300 Subject: [PATCH 8/8] fix a bad merge --- x/gov/testutil/expected_keepers_mocks.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/x/gov/testutil/expected_keepers_mocks.go b/x/gov/testutil/expected_keepers_mocks.go index a3cec4ce3fcb..451a0882fbd1 100644 --- a/x/gov/testutil/expected_keepers_mocks.go +++ b/x/gov/testutil/expected_keepers_mocks.go @@ -789,10 +789,10 @@ func (mr *MockBankKeeperMockRecorder) SetSendEnabled(ctx, denom, value interface } // SpendableBalanceByDenom mocks base method. -func (m *MockBankKeeper) SpendableBalanceByDenom(arg0 context.Context, arg1 *types1.QuerySpendableBalanceByDenomRequest) (*types1.QuerySpendableBalanceByDenomResponse, error) { +func (m *MockBankKeeper) SpendableBalanceByDenom(arg0 context.Context, arg1 *types0.QuerySpendableBalanceByDenomRequest) (*types0.QuerySpendableBalanceByDenomResponse, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "SpendableBalanceByDenom", arg0, arg1) - ret0, _ := ret[0].(*types1.QuerySpendableBalanceByDenomResponse) + ret0, _ := ret[0].(*types0.QuerySpendableBalanceByDenomResponse) ret1, _ := ret[1].(error) return ret0, ret1 }