diff --git a/CHANGELOG.md b/CHANGELOG.md index dc7fb9531aa..e7a493c4144 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -63,6 +63,7 @@ Ref: https://keepachangelog.com/en/1.0.0/ * (x/bank) [#11981](https://github.com/cosmos/cosmos-sdk/pull/11981) Create the `SetSendEnabled` endpoint for managing the bank's SendEnabled settings. * (x/auth) [#13210](https://github.com/cosmos/cosmos-sdk/pull/13210) Add `Query/AccountInfo` endpoint for simplified access to basic account info. * (x/consensus) [#12905](https://github.com/cosmos/cosmos-sdk/pull/12905) Create a new `x/consensus` module that is now responsible for maintaining Tendermint consensus parameters instead of `x/param`. Legacy types remain in order to facilitate parameter migration from the deprecated `x/params`. App developers should ensure that they execute `baseapp.MigrateParams` during their chain upgrade. These legacy types will be removed in a future release. +* (x/gov) [#13010](https://github.com/cosmos/cosmos-sdk/pull/13010) Add `cancel-proposal` feature to proposals. Now proposers can cancel the proposal prior to the proposal's voting period end time. * (client/tx) [#13670](https://github.com/cosmos/cosmos-sdk/pull/13670) Add validation in `BuildUnsignedTx` to prevent simple inclusion of valid mnemonics * [#13473](https://github.com/cosmos/cosmos-sdk/pull/13473) ADR-038: Go plugin system proposal * [#14356](https://github.com/cosmos/cosmos-sdk/pull/14356) Add `events.GetAttributes` and `event.GetAttribute` methods to simplify the retrieval of an attribute from event(s). @@ -215,9 +216,9 @@ Ref: https://keepachangelog.com/en/1.0.0/ * (x/gov) [#13160](https://github.com/cosmos/cosmos-sdk/pull/13160) Remove custom marshaling of proposl and voteoption. * (types) [#13430](https://github.com/cosmos/cosmos-sdk/pull/13430) Remove unused code `ResponseCheckTx` and `ResponseDeliverTx` * (store) [#13529](https://github.com/cosmos/cosmos-sdk/pull/13529) Add method `LatestVersion` to `MultiStore` interface, add method `SetQueryMultiStore` to baesapp to support alternative `MultiStore` implementation for query service. -* (pruning) [#13609](https://github.com/cosmos/cosmos-sdk/pull/13609) Move pruning package to be under store package -* [#13794](https://github.com/cosmos/cosmos-sdk/pull/13794) Most methods on `types/module.AppModule` have been moved to -extension interfaces. `module.Manager.Modules` is now of type `map[string]interface{}` to support in parallel the new +* (pruning) [#13609](https://github.com/cosmos/cosmos-sdk/pull/13609) Move pruning package to be under store package. +* [#13794](https://github.com/cosmos/cosmos-sdk/pull/13794) Most methods on `types/module.AppModule` have been moved to +extension interfaces. `module.Manager.Modules` is now of type `map[string]interface{}` to support in parallel the new `cosmossdk.io/core/appmodule.AppModule` API. * (signing) [#13701](https://github.com/cosmos/cosmos-sdk/pull/) Add `context.Context` as an argument `x/auth/signing.VerifySignature`. * (x/group) [#13876](https://github.com/cosmos/cosmos-sdk/pull/13876) Add `GetMinExecutionPeriod` method on DecisionPolicy interface. diff --git a/UPGRADING.md b/UPGRADING.md index b8c0a995504..8cf4c49ace9 100644 --- a/UPGRADING.md +++ b/UPGRADING.md @@ -173,6 +173,45 @@ By default, the new `MinInitialDepositRatio` parameter is set to zero during mig feature is disabled. If chains wish to utilize the minimum proposal deposits at time of submission, the migration logic needs to be modified to set the new parameter to the desired value. +##### New Proposal.Proposer field + +The `Proposal` proto has been updated with proposer field. For proposal state migraton developers can call `v4.AddProposerAddressToProposal` in their upgrade handler to update all existing proposal and make them compatible and this migration is optional. + +> This migration is optional, if chain wants to cancel previous proposals which are active (deposit or voting period) they can do this proposals state migration. + +```go +import ( + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/types/module" + v4 "github.com/cosmos/cosmos-sdk/x/gov/migrations/v4" + upgradetypes "github.com/cosmos/cosmos-sdk/x/upgrade/types" +) + +func (app SimApp) RegisterUpgradeHandlers() { + app.UpgradeKeeper.SetUpgradeHandler(UpgradeName, + func(ctx sdk.Context, plan upgradetypes.Plan, fromVM module.VersionMap) (module.VersionMap, error) { + // this migration is optional + // add proposal ids with proposers which are active (deposit or voting period) + proposals := make(map[uint64]string) + proposals[1] = "cosmos1luyncewxk4lm24k6gqy8y5dxkj0klr4tu0lmnj" ... + v4.AddProposerAddressToProposal(ctx, sdk.NewKVStoreKey(v4.ModuleName), app.appCodec, proposals) + return app.ModuleManager.RunMigrations(ctx, app.Configurator(), fromVM) + }) +} + +``` + +##### New Feature: Cancelling Proposals + +The `gov` module has been updated to support the ability to cancel governance proposals. When a proposal is canceled, all the deposits of the proposal are either burnt or sent to `ProposalCancelDest` address. The deposits burn rate will be determined by a new parameter called `ProposalCancelRatio` parameter. + +``` + 1. deposits * proposal_cancel_ratio will be burned or sent to `ProposalCancelDest` address , if `ProposalCancelDest` is empty then deposits will be burned. + 2. deposits * (1 - proposal_cancel_ratio) will be sent to depositors. +``` + +By default, the new `ProposalCancelRatio` parameter is set to 0.5 during migration and `ProposalCancelDest` is set to empty string (i.e. burnt). + #### `x/consensus` Introducing a new `x/consensus` module to handle managing Tendermint consensus diff --git a/api/cosmos/gov/v1/gov.pulsar.go b/api/cosmos/gov/v1/gov.pulsar.go index e61c58ada3f..505e4013148 100644 --- a/api/cosmos/gov/v1/gov.pulsar.go +++ b/api/cosmos/gov/v1/gov.pulsar.go @@ -5370,6 +5370,8 @@ var ( fd_Params_threshold protoreflect.FieldDescriptor fd_Params_veto_threshold protoreflect.FieldDescriptor fd_Params_min_initial_deposit_ratio protoreflect.FieldDescriptor + fd_Params_proposal_cancel_ratio protoreflect.FieldDescriptor + fd_Params_proposal_cancel_dest protoreflect.FieldDescriptor ) func init() { @@ -5382,6 +5384,8 @@ func init() { fd_Params_threshold = md_Params.Fields().ByName("threshold") fd_Params_veto_threshold = md_Params.Fields().ByName("veto_threshold") fd_Params_min_initial_deposit_ratio = md_Params.Fields().ByName("min_initial_deposit_ratio") + fd_Params_proposal_cancel_ratio = md_Params.Fields().ByName("proposal_cancel_ratio") + fd_Params_proposal_cancel_dest = md_Params.Fields().ByName("proposal_cancel_dest") } var _ protoreflect.Message = (*fastReflection_Params)(nil) @@ -5491,6 +5495,18 @@ func (x *fastReflection_Params) Range(f func(protoreflect.FieldDescriptor, proto return } } + if x.ProposalCancelRatio != "" { + value := protoreflect.ValueOfString(x.ProposalCancelRatio) + if !f(fd_Params_proposal_cancel_ratio, value) { + return + } + } + if x.ProposalCancelDest != "" { + value := protoreflect.ValueOfString(x.ProposalCancelDest) + if !f(fd_Params_proposal_cancel_dest, value) { + return + } + } } // Has reports whether a field is populated. @@ -5520,6 +5536,10 @@ func (x *fastReflection_Params) Has(fd protoreflect.FieldDescriptor) bool { return x.VetoThreshold != "" case "cosmos.gov.v1.Params.min_initial_deposit_ratio": return x.MinInitialDepositRatio != "" + case "cosmos.gov.v1.Params.proposal_cancel_ratio": + return x.ProposalCancelRatio != "" + case "cosmos.gov.v1.Params.proposal_cancel_dest": + return x.ProposalCancelDest != "" default: if fd.IsExtension() { panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.gov.v1.Params")) @@ -5550,6 +5570,10 @@ func (x *fastReflection_Params) Clear(fd protoreflect.FieldDescriptor) { x.VetoThreshold = "" case "cosmos.gov.v1.Params.min_initial_deposit_ratio": x.MinInitialDepositRatio = "" + case "cosmos.gov.v1.Params.proposal_cancel_ratio": + x.ProposalCancelRatio = "" + case "cosmos.gov.v1.Params.proposal_cancel_dest": + x.ProposalCancelDest = "" default: if fd.IsExtension() { panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.gov.v1.Params")) @@ -5590,6 +5614,12 @@ func (x *fastReflection_Params) Get(descriptor protoreflect.FieldDescriptor) pro case "cosmos.gov.v1.Params.min_initial_deposit_ratio": value := x.MinInitialDepositRatio return protoreflect.ValueOfString(value) + case "cosmos.gov.v1.Params.proposal_cancel_ratio": + value := x.ProposalCancelRatio + return protoreflect.ValueOfString(value) + case "cosmos.gov.v1.Params.proposal_cancel_dest": + value := x.ProposalCancelDest + return protoreflect.ValueOfString(value) default: if descriptor.IsExtension() { panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.gov.v1.Params")) @@ -5626,6 +5656,10 @@ func (x *fastReflection_Params) Set(fd protoreflect.FieldDescriptor, value proto x.VetoThreshold = value.Interface().(string) case "cosmos.gov.v1.Params.min_initial_deposit_ratio": x.MinInitialDepositRatio = value.Interface().(string) + case "cosmos.gov.v1.Params.proposal_cancel_ratio": + x.ProposalCancelRatio = value.Interface().(string) + case "cosmos.gov.v1.Params.proposal_cancel_dest": + x.ProposalCancelDest = value.Interface().(string) default: if fd.IsExtension() { panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.gov.v1.Params")) @@ -5670,6 +5704,10 @@ func (x *fastReflection_Params) Mutable(fd protoreflect.FieldDescriptor) protore panic(fmt.Errorf("field veto_threshold of message cosmos.gov.v1.Params is not mutable")) case "cosmos.gov.v1.Params.min_initial_deposit_ratio": panic(fmt.Errorf("field min_initial_deposit_ratio of message cosmos.gov.v1.Params is not mutable")) + case "cosmos.gov.v1.Params.proposal_cancel_ratio": + panic(fmt.Errorf("field proposal_cancel_ratio of message cosmos.gov.v1.Params is not mutable")) + case "cosmos.gov.v1.Params.proposal_cancel_dest": + panic(fmt.Errorf("field proposal_cancel_dest of message cosmos.gov.v1.Params is not mutable")) default: if fd.IsExtension() { panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.gov.v1.Params")) @@ -5700,6 +5738,10 @@ func (x *fastReflection_Params) NewField(fd protoreflect.FieldDescriptor) protor return protoreflect.ValueOfString("") case "cosmos.gov.v1.Params.min_initial_deposit_ratio": return protoreflect.ValueOfString("") + case "cosmos.gov.v1.Params.proposal_cancel_ratio": + return protoreflect.ValueOfString("") + case "cosmos.gov.v1.Params.proposal_cancel_dest": + return protoreflect.ValueOfString("") default: if fd.IsExtension() { panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.gov.v1.Params")) @@ -5799,6 +5841,14 @@ func (x *fastReflection_Params) ProtoMethods() *protoiface.Methods { if l > 0 { n += 1 + l + runtime.Sov(uint64(l)) } + l = len(x.ProposalCancelRatio) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.ProposalCancelDest) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } if x.unknownFields != nil { n += len(x.unknownFields) } @@ -5828,6 +5878,20 @@ func (x *fastReflection_Params) ProtoMethods() *protoiface.Methods { i -= len(x.unknownFields) copy(dAtA[i:], x.unknownFields) } + if len(x.ProposalCancelDest) > 0 { + i -= len(x.ProposalCancelDest) + copy(dAtA[i:], x.ProposalCancelDest) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ProposalCancelDest))) + i-- + dAtA[i] = 0x4a + } + if len(x.ProposalCancelRatio) > 0 { + i -= len(x.ProposalCancelRatio) + copy(dAtA[i:], x.ProposalCancelRatio) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ProposalCancelRatio))) + i-- + dAtA[i] = 0x42 + } if len(x.MinInitialDepositRatio) > 0 { i -= len(x.MinInitialDepositRatio) copy(dAtA[i:], x.MinInitialDepositRatio) @@ -6183,6 +6247,70 @@ func (x *fastReflection_Params) ProtoMethods() *protoiface.Methods { } x.MinInitialDepositRatio = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex + case 8: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ProposalCancelRatio", 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.ProposalCancelRatio = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 9: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ProposalCancelDest", 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.ProposalCancelDest = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := runtime.Skip(dAtA[iNdEx:]) @@ -6914,6 +7042,15 @@ type Params struct { VetoThreshold string `protobuf:"bytes,6,opt,name=veto_threshold,json=vetoThreshold,proto3" json:"veto_threshold,omitempty"` // The ratio representing the proportion of the deposit value that must be paid at proposal submission. MinInitialDepositRatio string `protobuf:"bytes,7,opt,name=min_initial_deposit_ratio,json=minInitialDepositRatio,proto3" json:"min_initial_deposit_ratio,omitempty"` + // The cancel ratio which will not be returned back to the depositors when a proposal is cancelled. + // + // Since: cosmos-sdk 0.48 + ProposalCancelRatio string `protobuf:"bytes,8,opt,name=proposal_cancel_ratio,json=proposalCancelRatio,proto3" json:"proposal_cancel_ratio,omitempty"` + // The address which will receive (proposal_cancel_ratio * deposit) proposal deposits. + // If empty, the (proposal_cancel_ratio * deposit) proposal deposits will be burned. + // + // Since: cosmos-sdk 0.48 + ProposalCancelDest string `protobuf:"bytes,9,opt,name=proposal_cancel_dest,json=proposalCancelDest,proto3" json:"proposal_cancel_dest,omitempty"` } func (x *Params) Reset() { @@ -6985,6 +7122,20 @@ func (x *Params) GetMinInitialDepositRatio() string { return "" } +func (x *Params) GetProposalCancelRatio() string { + if x != nil { + return x.ProposalCancelRatio + } + return "" +} + +func (x *Params) GetProposalCancelDest() string { + if x != nil { + return x.ProposalCancelDest + } + return "" +} + var File_cosmos_gov_v1_gov_proto protoreflect.FileDescriptor var file_cosmos_gov_v1_gov_proto_rawDesc = []byte{ @@ -7118,7 +7269,7 @@ var file_cosmos_gov_v1_gov_proto_rawDesc = []byte{ 0x65, 0x74, 0x6f, 0x5f, 0x74, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x42, 0x0e, 0xd2, 0xb4, 0x2d, 0x0a, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x44, 0x65, 0x63, 0x52, 0x0d, 0x76, 0x65, 0x74, 0x6f, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, - 0x6c, 0x64, 0x22, 0xbc, 0x03, 0x0a, 0x06, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x45, 0x0a, + 0x6c, 0x64, 0x22, 0xcc, 0x04, 0x0a, 0x06, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x45, 0x0a, 0x0b, 0x6d, 0x69, 0x6e, 0x5f, 0x64, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 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, 0x09, 0xc8, @@ -7146,7 +7297,16 @@ var file_cosmos_gov_v1_gov_proto_rawDesc = []byte{ 0x74, 0x69, 0x6f, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x42, 0x0e, 0xd2, 0xb4, 0x2d, 0x0a, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x44, 0x65, 0x63, 0x52, 0x16, 0x6d, 0x69, 0x6e, 0x49, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x52, 0x61, 0x74, 0x69, - 0x6f, 0x2a, 0x89, 0x01, 0x0a, 0x0a, 0x56, 0x6f, 0x74, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, + 0x6f, 0x12, 0x42, 0x0a, 0x15, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x5f, 0x63, 0x61, + 0x6e, 0x63, 0x65, 0x6c, 0x5f, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, + 0x42, 0x0e, 0xd2, 0xb4, 0x2d, 0x0a, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x44, 0x65, 0x63, + 0x52, 0x13, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, + 0x52, 0x61, 0x74, 0x69, 0x6f, 0x12, 0x4a, 0x0a, 0x14, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, + 0x6c, 0x5f, 0x63, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x5f, 0x64, 0x65, 0x73, 0x74, 0x18, 0x09, 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, 0x12, 0x70, + 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x44, 0x65, 0x73, + 0x74, 0x2a, 0x89, 0x01, 0x0a, 0x0a, 0x56, 0x6f, 0x74, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1b, 0x0a, 0x17, 0x56, 0x4f, 0x54, 0x45, 0x5f, 0x4f, 0x50, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x13, 0x0a, 0x0f, 0x56, 0x4f, 0x54, 0x45, 0x5f, 0x4f, 0x50, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x59, 0x45, 0x53, diff --git a/api/cosmos/gov/v1/tx.pulsar.go b/api/cosmos/gov/v1/tx.pulsar.go index e2062e7017e..d9048fb0005 100644 --- a/api/cosmos/gov/v1/tx.pulsar.go +++ b/api/cosmos/gov/v1/tx.pulsar.go @@ -13,6 +13,7 @@ import ( protoiface "google.golang.org/protobuf/runtime/protoiface" protoimpl "google.golang.org/protobuf/runtime/protoimpl" anypb "google.golang.org/protobuf/types/known/anypb" + timestamppb "google.golang.org/protobuf/types/known/timestamppb" io "io" reflect "reflect" sync "sync" @@ -5944,6 +5945,1005 @@ func (x *fastReflection_MsgUpdateParamsResponse) ProtoMethods() *protoiface.Meth } } +var ( + md_MsgCancelProposal protoreflect.MessageDescriptor + fd_MsgCancelProposal_proposal_id protoreflect.FieldDescriptor + fd_MsgCancelProposal_proposer protoreflect.FieldDescriptor +) + +func init() { + file_cosmos_gov_v1_tx_proto_init() + md_MsgCancelProposal = File_cosmos_gov_v1_tx_proto.Messages().ByName("MsgCancelProposal") + fd_MsgCancelProposal_proposal_id = md_MsgCancelProposal.Fields().ByName("proposal_id") + fd_MsgCancelProposal_proposer = md_MsgCancelProposal.Fields().ByName("proposer") +} + +var _ protoreflect.Message = (*fastReflection_MsgCancelProposal)(nil) + +type fastReflection_MsgCancelProposal MsgCancelProposal + +func (x *MsgCancelProposal) ProtoReflect() protoreflect.Message { + return (*fastReflection_MsgCancelProposal)(x) +} + +func (x *MsgCancelProposal) slowProtoReflect() protoreflect.Message { + mi := &file_cosmos_gov_v1_tx_proto_msgTypes[12] + 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_MsgCancelProposal_messageType fastReflection_MsgCancelProposal_messageType +var _ protoreflect.MessageType = fastReflection_MsgCancelProposal_messageType{} + +type fastReflection_MsgCancelProposal_messageType struct{} + +func (x fastReflection_MsgCancelProposal_messageType) Zero() protoreflect.Message { + return (*fastReflection_MsgCancelProposal)(nil) +} +func (x fastReflection_MsgCancelProposal_messageType) New() protoreflect.Message { + return new(fastReflection_MsgCancelProposal) +} +func (x fastReflection_MsgCancelProposal_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MsgCancelProposal +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MsgCancelProposal) Descriptor() protoreflect.MessageDescriptor { + return md_MsgCancelProposal +} + +// 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_MsgCancelProposal) Type() protoreflect.MessageType { + return _fastReflection_MsgCancelProposal_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MsgCancelProposal) New() protoreflect.Message { + return new(fastReflection_MsgCancelProposal) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MsgCancelProposal) Interface() protoreflect.ProtoMessage { + return (*MsgCancelProposal)(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_MsgCancelProposal) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.ProposalId != uint64(0) { + value := protoreflect.ValueOfUint64(x.ProposalId) + if !f(fd_MsgCancelProposal_proposal_id, value) { + return + } + } + if x.Proposer != "" { + value := protoreflect.ValueOfString(x.Proposer) + if !f(fd_MsgCancelProposal_proposer, 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_MsgCancelProposal) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "cosmos.gov.v1.MsgCancelProposal.proposal_id": + return x.ProposalId != uint64(0) + case "cosmos.gov.v1.MsgCancelProposal.proposer": + return x.Proposer != "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.gov.v1.MsgCancelProposal")) + } + panic(fmt.Errorf("message cosmos.gov.v1.MsgCancelProposal 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_MsgCancelProposal) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "cosmos.gov.v1.MsgCancelProposal.proposal_id": + x.ProposalId = uint64(0) + case "cosmos.gov.v1.MsgCancelProposal.proposer": + x.Proposer = "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.gov.v1.MsgCancelProposal")) + } + panic(fmt.Errorf("message cosmos.gov.v1.MsgCancelProposal 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_MsgCancelProposal) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "cosmos.gov.v1.MsgCancelProposal.proposal_id": + value := x.ProposalId + return protoreflect.ValueOfUint64(value) + case "cosmos.gov.v1.MsgCancelProposal.proposer": + value := x.Proposer + return protoreflect.ValueOfString(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.gov.v1.MsgCancelProposal")) + } + panic(fmt.Errorf("message cosmos.gov.v1.MsgCancelProposal 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_MsgCancelProposal) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "cosmos.gov.v1.MsgCancelProposal.proposal_id": + x.ProposalId = value.Uint() + case "cosmos.gov.v1.MsgCancelProposal.proposer": + x.Proposer = value.Interface().(string) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.gov.v1.MsgCancelProposal")) + } + panic(fmt.Errorf("message cosmos.gov.v1.MsgCancelProposal 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_MsgCancelProposal) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.gov.v1.MsgCancelProposal.proposal_id": + panic(fmt.Errorf("field proposal_id of message cosmos.gov.v1.MsgCancelProposal is not mutable")) + case "cosmos.gov.v1.MsgCancelProposal.proposer": + panic(fmt.Errorf("field proposer of message cosmos.gov.v1.MsgCancelProposal is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.gov.v1.MsgCancelProposal")) + } + panic(fmt.Errorf("message cosmos.gov.v1.MsgCancelProposal 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_MsgCancelProposal) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.gov.v1.MsgCancelProposal.proposal_id": + return protoreflect.ValueOfUint64(uint64(0)) + case "cosmos.gov.v1.MsgCancelProposal.proposer": + return protoreflect.ValueOfString("") + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.gov.v1.MsgCancelProposal")) + } + panic(fmt.Errorf("message cosmos.gov.v1.MsgCancelProposal 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_MsgCancelProposal) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in cosmos.gov.v1.MsgCancelProposal", 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_MsgCancelProposal) 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_MsgCancelProposal) 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_MsgCancelProposal) 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_MsgCancelProposal) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MsgCancelProposal) + 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.ProposalId != 0 { + n += 1 + runtime.Sov(uint64(x.ProposalId)) + } + l = len(x.Proposer) + 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().(*MsgCancelProposal) + 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.Proposer) > 0 { + i -= len(x.Proposer) + copy(dAtA[i:], x.Proposer) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Proposer))) + i-- + dAtA[i] = 0x12 + } + if x.ProposalId != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.ProposalId)) + i-- + dAtA[i] = 0x8 + } + 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().(*MsgCancelProposal) + 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: MsgCancelProposal: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgCancelProposal: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ProposalId", wireType) + } + x.ProposalId = 0 + 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++ + x.ProposalId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Proposer", 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.Proposer = 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_MsgCancelProposalResponse protoreflect.MessageDescriptor + fd_MsgCancelProposalResponse_proposal_id protoreflect.FieldDescriptor + fd_MsgCancelProposalResponse_canceled_time protoreflect.FieldDescriptor + fd_MsgCancelProposalResponse_canceled_height protoreflect.FieldDescriptor +) + +func init() { + file_cosmos_gov_v1_tx_proto_init() + md_MsgCancelProposalResponse = File_cosmos_gov_v1_tx_proto.Messages().ByName("MsgCancelProposalResponse") + fd_MsgCancelProposalResponse_proposal_id = md_MsgCancelProposalResponse.Fields().ByName("proposal_id") + fd_MsgCancelProposalResponse_canceled_time = md_MsgCancelProposalResponse.Fields().ByName("canceled_time") + fd_MsgCancelProposalResponse_canceled_height = md_MsgCancelProposalResponse.Fields().ByName("canceled_height") +} + +var _ protoreflect.Message = (*fastReflection_MsgCancelProposalResponse)(nil) + +type fastReflection_MsgCancelProposalResponse MsgCancelProposalResponse + +func (x *MsgCancelProposalResponse) ProtoReflect() protoreflect.Message { + return (*fastReflection_MsgCancelProposalResponse)(x) +} + +func (x *MsgCancelProposalResponse) slowProtoReflect() protoreflect.Message { + mi := &file_cosmos_gov_v1_tx_proto_msgTypes[13] + 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_MsgCancelProposalResponse_messageType fastReflection_MsgCancelProposalResponse_messageType +var _ protoreflect.MessageType = fastReflection_MsgCancelProposalResponse_messageType{} + +type fastReflection_MsgCancelProposalResponse_messageType struct{} + +func (x fastReflection_MsgCancelProposalResponse_messageType) Zero() protoreflect.Message { + return (*fastReflection_MsgCancelProposalResponse)(nil) +} +func (x fastReflection_MsgCancelProposalResponse_messageType) New() protoreflect.Message { + return new(fastReflection_MsgCancelProposalResponse) +} +func (x fastReflection_MsgCancelProposalResponse_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MsgCancelProposalResponse +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MsgCancelProposalResponse) Descriptor() protoreflect.MessageDescriptor { + return md_MsgCancelProposalResponse +} + +// 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_MsgCancelProposalResponse) Type() protoreflect.MessageType { + return _fastReflection_MsgCancelProposalResponse_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MsgCancelProposalResponse) New() protoreflect.Message { + return new(fastReflection_MsgCancelProposalResponse) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MsgCancelProposalResponse) Interface() protoreflect.ProtoMessage { + return (*MsgCancelProposalResponse)(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_MsgCancelProposalResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.ProposalId != uint64(0) { + value := protoreflect.ValueOfUint64(x.ProposalId) + if !f(fd_MsgCancelProposalResponse_proposal_id, value) { + return + } + } + if x.CanceledTime != nil { + value := protoreflect.ValueOfMessage(x.CanceledTime.ProtoReflect()) + if !f(fd_MsgCancelProposalResponse_canceled_time, value) { + return + } + } + if x.CanceledHeight != uint64(0) { + value := protoreflect.ValueOfUint64(x.CanceledHeight) + if !f(fd_MsgCancelProposalResponse_canceled_height, 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_MsgCancelProposalResponse) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "cosmos.gov.v1.MsgCancelProposalResponse.proposal_id": + return x.ProposalId != uint64(0) + case "cosmos.gov.v1.MsgCancelProposalResponse.canceled_time": + return x.CanceledTime != nil + case "cosmos.gov.v1.MsgCancelProposalResponse.canceled_height": + return x.CanceledHeight != uint64(0) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.gov.v1.MsgCancelProposalResponse")) + } + panic(fmt.Errorf("message cosmos.gov.v1.MsgCancelProposalResponse 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_MsgCancelProposalResponse) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "cosmos.gov.v1.MsgCancelProposalResponse.proposal_id": + x.ProposalId = uint64(0) + case "cosmos.gov.v1.MsgCancelProposalResponse.canceled_time": + x.CanceledTime = nil + case "cosmos.gov.v1.MsgCancelProposalResponse.canceled_height": + x.CanceledHeight = uint64(0) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.gov.v1.MsgCancelProposalResponse")) + } + panic(fmt.Errorf("message cosmos.gov.v1.MsgCancelProposalResponse 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_MsgCancelProposalResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "cosmos.gov.v1.MsgCancelProposalResponse.proposal_id": + value := x.ProposalId + return protoreflect.ValueOfUint64(value) + case "cosmos.gov.v1.MsgCancelProposalResponse.canceled_time": + value := x.CanceledTime + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "cosmos.gov.v1.MsgCancelProposalResponse.canceled_height": + value := x.CanceledHeight + return protoreflect.ValueOfUint64(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.gov.v1.MsgCancelProposalResponse")) + } + panic(fmt.Errorf("message cosmos.gov.v1.MsgCancelProposalResponse 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_MsgCancelProposalResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "cosmos.gov.v1.MsgCancelProposalResponse.proposal_id": + x.ProposalId = value.Uint() + case "cosmos.gov.v1.MsgCancelProposalResponse.canceled_time": + x.CanceledTime = value.Message().Interface().(*timestamppb.Timestamp) + case "cosmos.gov.v1.MsgCancelProposalResponse.canceled_height": + x.CanceledHeight = value.Uint() + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.gov.v1.MsgCancelProposalResponse")) + } + panic(fmt.Errorf("message cosmos.gov.v1.MsgCancelProposalResponse 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_MsgCancelProposalResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.gov.v1.MsgCancelProposalResponse.canceled_time": + if x.CanceledTime == nil { + x.CanceledTime = new(timestamppb.Timestamp) + } + return protoreflect.ValueOfMessage(x.CanceledTime.ProtoReflect()) + case "cosmos.gov.v1.MsgCancelProposalResponse.proposal_id": + panic(fmt.Errorf("field proposal_id of message cosmos.gov.v1.MsgCancelProposalResponse is not mutable")) + case "cosmos.gov.v1.MsgCancelProposalResponse.canceled_height": + panic(fmt.Errorf("field canceled_height of message cosmos.gov.v1.MsgCancelProposalResponse is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.gov.v1.MsgCancelProposalResponse")) + } + panic(fmt.Errorf("message cosmos.gov.v1.MsgCancelProposalResponse 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_MsgCancelProposalResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.gov.v1.MsgCancelProposalResponse.proposal_id": + return protoreflect.ValueOfUint64(uint64(0)) + case "cosmos.gov.v1.MsgCancelProposalResponse.canceled_time": + m := new(timestamppb.Timestamp) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "cosmos.gov.v1.MsgCancelProposalResponse.canceled_height": + return protoreflect.ValueOfUint64(uint64(0)) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.gov.v1.MsgCancelProposalResponse")) + } + panic(fmt.Errorf("message cosmos.gov.v1.MsgCancelProposalResponse 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_MsgCancelProposalResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in cosmos.gov.v1.MsgCancelProposalResponse", 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_MsgCancelProposalResponse) 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_MsgCancelProposalResponse) 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_MsgCancelProposalResponse) 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_MsgCancelProposalResponse) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MsgCancelProposalResponse) + 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.ProposalId != 0 { + n += 1 + runtime.Sov(uint64(x.ProposalId)) + } + if x.CanceledTime != nil { + l = options.Size(x.CanceledTime) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.CanceledHeight != 0 { + n += 1 + runtime.Sov(uint64(x.CanceledHeight)) + } + 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().(*MsgCancelProposalResponse) + 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.CanceledHeight != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.CanceledHeight)) + i-- + dAtA[i] = 0x18 + } + if x.CanceledTime != nil { + encoded, err := options.Marshal(x.CanceledTime) + 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] = 0x12 + } + if x.ProposalId != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.ProposalId)) + i-- + dAtA[i] = 0x8 + } + 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().(*MsgCancelProposalResponse) + 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: MsgCancelProposalResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgCancelProposalResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ProposalId", wireType) + } + x.ProposalId = 0 + 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++ + x.ProposalId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field CanceledTime", 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.CanceledTime == nil { + x.CanceledTime = ×tamppb.Timestamp{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.CanceledTime); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 3: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field CanceledHeight", wireType) + } + x.CanceledHeight = 0 + 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++ + x.CanceledHeight |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + 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, + } +} + // Since: cosmos-sdk 0.46 // Code generated by protoc-gen-go. DO NOT EDIT. @@ -6501,6 +7501,109 @@ func (*MsgUpdateParamsResponse) Descriptor() ([]byte, []int) { return file_cosmos_gov_v1_tx_proto_rawDescGZIP(), []int{11} } +// MsgCancelProposal is the Msg/CancelProposal request type. +// +// Since: cosmos-sdk 0.48 +type MsgCancelProposal struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ProposalId uint64 `protobuf:"varint,1,opt,name=proposal_id,json=proposalId,proto3" json:"proposal_id,omitempty"` + Proposer string `protobuf:"bytes,2,opt,name=proposer,proto3" json:"proposer,omitempty"` +} + +func (x *MsgCancelProposal) Reset() { + *x = MsgCancelProposal{} + if protoimpl.UnsafeEnabled { + mi := &file_cosmos_gov_v1_tx_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MsgCancelProposal) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MsgCancelProposal) ProtoMessage() {} + +// Deprecated: Use MsgCancelProposal.ProtoReflect.Descriptor instead. +func (*MsgCancelProposal) Descriptor() ([]byte, []int) { + return file_cosmos_gov_v1_tx_proto_rawDescGZIP(), []int{12} +} + +func (x *MsgCancelProposal) GetProposalId() uint64 { + if x != nil { + return x.ProposalId + } + return 0 +} + +func (x *MsgCancelProposal) GetProposer() string { + if x != nil { + return x.Proposer + } + return "" +} + +// MsgCancelProposalResponse defines the response structure for executing a +// MsgCancelProposal message. +// +// Since: cosmos-sdk 0.48 +type MsgCancelProposalResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ProposalId uint64 `protobuf:"varint,1,opt,name=proposal_id,json=proposalId,proto3" json:"proposal_id,omitempty"` + // canceled_time is the time when proposal is canceled. + CanceledTime *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=canceled_time,json=canceledTime,proto3" json:"canceled_time,omitempty"` + // canceled_height defines the block height at which the proposal is canceled. + CanceledHeight uint64 `protobuf:"varint,3,opt,name=canceled_height,json=canceledHeight,proto3" json:"canceled_height,omitempty"` +} + +func (x *MsgCancelProposalResponse) Reset() { + *x = MsgCancelProposalResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_cosmos_gov_v1_tx_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MsgCancelProposalResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MsgCancelProposalResponse) ProtoMessage() {} + +// Deprecated: Use MsgCancelProposalResponse.ProtoReflect.Descriptor instead. +func (*MsgCancelProposalResponse) Descriptor() ([]byte, []int) { + return file_cosmos_gov_v1_tx_proto_rawDescGZIP(), []int{13} +} + +func (x *MsgCancelProposalResponse) GetProposalId() uint64 { + if x != nil { + return x.ProposalId + } + return 0 +} + +func (x *MsgCancelProposalResponse) GetCanceledTime() *timestamppb.Timestamp { + if x != nil { + return x.CanceledTime + } + return nil +} + +func (x *MsgCancelProposalResponse) GetCanceledHeight() uint64 { + if x != nil { + return x.CanceledHeight + } + return 0 +} + var File_cosmos_gov_v1_tx_proto protoreflect.FileDescriptor var file_cosmos_gov_v1_tx_proto_rawDesc = []byte{ @@ -6517,140 +7620,169 @@ var file_cosmos_gov_v1_tx_proto_rawDesc = []byte{ 0x75, 0x66, 0x2f, 0x61, 0x6e, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x17, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x6d, 0x73, 0x67, 0x2f, 0x76, 0x31, 0x2f, 0x6d, 0x73, 0x67, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x11, 0x61, 0x6d, 0x69, 0x6e, 0x6f, 0x2f, 0x61, 0x6d, 0x69, - 0x6e, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xc9, 0x02, 0x0a, 0x11, 0x4d, 0x73, 0x67, - 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x12, 0x30, - 0x0a, 0x08, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, - 0x32, 0x14, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, - 0x75, 0x66, 0x2e, 0x41, 0x6e, 0x79, 0x52, 0x08, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, - 0x12, 0x4d, 0x0a, 0x0f, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x5f, 0x64, 0x65, 0x70, 0x6f, - 0x73, 0x69, 0x74, 0x18, 0x02, 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, 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, - 0x0e, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x12, - 0x34, 0x0a, 0x08, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x72, 0x18, 0x03, 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, 0x08, 0x70, 0x72, 0x6f, - 0x70, 0x6f, 0x73, 0x65, 0x72, 0x12, 0x1a, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, - 0x61, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, - 0x61, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x05, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x73, 0x75, 0x6d, 0x6d, 0x61, - 0x72, 0x79, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x73, 0x75, 0x6d, 0x6d, 0x61, 0x72, - 0x79, 0x3a, 0x31, 0x82, 0xe7, 0xb0, 0x2a, 0x08, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x72, - 0x8a, 0xe7, 0xb0, 0x2a, 0x1f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2d, 0x73, 0x64, 0x6b, 0x2f, - 0x76, 0x31, 0x2f, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x50, 0x72, 0x6f, 0x70, - 0x6f, 0x73, 0x61, 0x6c, 0x22, 0x3c, 0x0a, 0x19, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, - 0x74, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x5f, 0x69, 0x64, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, - 0x49, 0x64, 0x22, 0xbb, 0x01, 0x0a, 0x14, 0x4d, 0x73, 0x67, 0x45, 0x78, 0x65, 0x63, 0x4c, 0x65, - 0x67, 0x61, 0x63, 0x79, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x12, 0x4e, 0x0a, 0x07, 0x63, - 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, - 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x41, - 0x6e, 0x79, 0x42, 0x1e, 0xca, 0xb4, 0x2d, 0x1a, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x67, - 0x6f, 0x76, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x65, - 0x6e, 0x74, 0x52, 0x07, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x61, - 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, - 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x3a, 0x35, 0x82, 0xe7, 0xb0, 0x2a, 0x09, - 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x8a, 0xe7, 0xb0, 0x2a, 0x22, 0x63, 0x6f, - 0x73, 0x6d, 0x6f, 0x73, 0x2d, 0x73, 0x64, 0x6b, 0x2f, 0x76, 0x31, 0x2f, 0x4d, 0x73, 0x67, 0x45, - 0x78, 0x65, 0x63, 0x4c, 0x65, 0x67, 0x61, 0x63, 0x79, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, - 0x22, 0x1e, 0x0a, 0x1c, 0x4d, 0x73, 0x67, 0x45, 0x78, 0x65, 0x63, 0x4c, 0x65, 0x67, 0x61, 0x63, - 0x79, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x22, 0xe5, 0x01, 0x0a, 0x07, 0x4d, 0x73, 0x67, 0x56, 0x6f, 0x74, 0x65, 0x12, 0x35, 0x0a, 0x0b, - 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x04, 0x42, 0x14, 0xea, 0xde, 0x1f, 0x0b, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x5f, - 0x69, 0x64, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x0a, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, - 0x6c, 0x49, 0x64, 0x12, 0x2e, 0x0a, 0x05, 0x76, 0x6f, 0x74, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, + 0x6e, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, + 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, + 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xc9, 0x02, 0x0a, 0x11, 0x4d, 0x73, + 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x12, + 0x30, 0x0a, 0x08, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x62, 0x75, 0x66, 0x2e, 0x41, 0x6e, 0x79, 0x52, 0x08, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x73, 0x12, 0x4d, 0x0a, 0x0f, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x5f, 0x64, 0x65, 0x70, + 0x6f, 0x73, 0x69, 0x74, 0x18, 0x02, 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, 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, + 0x52, 0x0e, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, + 0x12, 0x34, 0x0a, 0x08, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x72, 0x18, 0x03, 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, 0x05, 0x76, 0x6f, - 0x74, 0x65, 0x72, 0x12, 0x31, 0x0a, 0x06, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, - 0x01, 0x28, 0x0e, 0x32, 0x19, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x67, 0x6f, 0x76, - 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x6f, 0x74, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x06, - 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1a, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x08, 0x70, 0x72, + 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x72, 0x12, 0x1a, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, - 0x74, 0x61, 0x3a, 0x24, 0x82, 0xe7, 0xb0, 0x2a, 0x05, 0x76, 0x6f, 0x74, 0x65, 0x72, 0x8a, 0xe7, - 0xb0, 0x2a, 0x15, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2d, 0x73, 0x64, 0x6b, 0x2f, 0x76, 0x31, - 0x2f, 0x4d, 0x73, 0x67, 0x56, 0x6f, 0x74, 0x65, 0x22, 0x11, 0x0a, 0x0f, 0x4d, 0x73, 0x67, 0x56, - 0x6f, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xff, 0x01, 0x0a, 0x0f, - 0x4d, 0x73, 0x67, 0x56, 0x6f, 0x74, 0x65, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x65, 0x64, 0x12, - 0x35, 0x0a, 0x0b, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x04, 0x42, 0x14, 0xea, 0xde, 0x1f, 0x0b, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, - 0x61, 0x6c, 0x5f, 0x69, 0x64, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x0a, 0x70, 0x72, 0x6f, 0x70, - 0x6f, 0x73, 0x61, 0x6c, 0x49, 0x64, 0x12, 0x2e, 0x0a, 0x05, 0x76, 0x6f, 0x74, 0x65, 0x72, 0x18, - 0x02, 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, - 0x05, 0x76, 0x6f, 0x74, 0x65, 0x72, 0x12, 0x3b, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, - 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, - 0x2e, 0x67, 0x6f, 0x76, 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x65, 0x64, - 0x56, 0x6f, 0x74, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, - 0x6f, 0x6e, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, - 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x3a, - 0x2c, 0x82, 0xe7, 0xb0, 0x2a, 0x05, 0x76, 0x6f, 0x74, 0x65, 0x72, 0x8a, 0xe7, 0xb0, 0x2a, 0x1d, - 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2d, 0x73, 0x64, 0x6b, 0x2f, 0x76, 0x31, 0x2f, 0x4d, 0x73, - 0x67, 0x56, 0x6f, 0x74, 0x65, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x65, 0x64, 0x22, 0x19, 0x0a, - 0x17, 0x4d, 0x73, 0x67, 0x56, 0x6f, 0x74, 0x65, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x65, 0x64, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xe6, 0x01, 0x0a, 0x0a, 0x4d, 0x73, 0x67, - 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x12, 0x35, 0x0a, 0x0b, 0x70, 0x72, 0x6f, 0x70, 0x6f, - 0x73, 0x61, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x42, 0x14, 0xea, 0xde, - 0x1f, 0x0b, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x5f, 0x69, 0x64, 0xa8, 0xe7, 0xb0, - 0x2a, 0x01, 0x52, 0x0a, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x49, 0x64, 0x12, 0x36, - 0x0a, 0x09, 0x64, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x18, 0x02, 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, 0x09, 0x64, 0x65, 0x70, - 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x12, 0x3c, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, - 0x18, 0x03, 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, 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x06, 0x61, 0x6d, - 0x6f, 0x75, 0x6e, 0x74, 0x3a, 0x2b, 0x82, 0xe7, 0xb0, 0x2a, 0x09, 0x64, 0x65, 0x70, 0x6f, 0x73, - 0x69, 0x74, 0x6f, 0x72, 0x8a, 0xe7, 0xb0, 0x2a, 0x18, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2d, - 0x73, 0x64, 0x6b, 0x2f, 0x76, 0x31, 0x2f, 0x4d, 0x73, 0x67, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, - 0x74, 0x22, 0x14, 0x0a, 0x12, 0x4d, 0x73, 0x67, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xbb, 0x01, 0x0a, 0x0f, 0x4d, 0x73, 0x67, 0x55, - 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x36, 0x0a, 0x09, 0x61, - 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 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, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, - 0x69, 0x74, 0x79, 0x12, 0x38, 0x0a, 0x06, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x67, 0x6f, 0x76, - 0x2e, 0x76, 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, 0x3a, 0x36, 0x82, - 0xe7, 0xb0, 0x2a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x8a, 0xe7, 0xb0, - 0x2a, 0x23, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2d, 0x73, 0x64, 0x6b, 0x2f, 0x78, 0x2f, 0x67, - 0x6f, 0x76, 0x2f, 0x76, 0x31, 0x2f, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, - 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x19, 0x0a, 0x17, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, - 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x32, 0x8a, 0x04, 0x0a, 0x03, 0x4d, 0x73, 0x67, 0x12, 0x5c, 0x0a, 0x0e, 0x53, 0x75, 0x62, 0x6d, - 0x69, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x12, 0x20, 0x2e, 0x63, 0x6f, 0x73, - 0x6d, 0x6f, 0x73, 0x2e, 0x67, 0x6f, 0x76, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x75, - 0x62, 0x6d, 0x69, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x1a, 0x28, 0x2e, 0x63, + 0x74, 0x61, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x05, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x73, 0x75, 0x6d, 0x6d, + 0x61, 0x72, 0x79, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x73, 0x75, 0x6d, 0x6d, 0x61, + 0x72, 0x79, 0x3a, 0x31, 0x82, 0xe7, 0xb0, 0x2a, 0x08, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, + 0x72, 0x8a, 0xe7, 0xb0, 0x2a, 0x1f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2d, 0x73, 0x64, 0x6b, + 0x2f, 0x76, 0x31, 0x2f, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x50, 0x72, 0x6f, + 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x22, 0x3c, 0x0a, 0x19, 0x4d, 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, + 0x69, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x5f, 0x69, + 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, + 0x6c, 0x49, 0x64, 0x22, 0xbb, 0x01, 0x0a, 0x14, 0x4d, 0x73, 0x67, 0x45, 0x78, 0x65, 0x63, 0x4c, + 0x65, 0x67, 0x61, 0x63, 0x79, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x12, 0x4e, 0x0a, 0x07, + 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, + 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, + 0x41, 0x6e, 0x79, 0x42, 0x1e, 0xca, 0xb4, 0x2d, 0x1a, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, + 0x67, 0x6f, 0x76, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74, + 0x65, 0x6e, 0x74, 0x52, 0x07, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x12, 0x1c, 0x0a, 0x09, + 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x3a, 0x35, 0x82, 0xe7, 0xb0, 0x2a, + 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x8a, 0xe7, 0xb0, 0x2a, 0x22, 0x63, + 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2d, 0x73, 0x64, 0x6b, 0x2f, 0x76, 0x31, 0x2f, 0x4d, 0x73, 0x67, + 0x45, 0x78, 0x65, 0x63, 0x4c, 0x65, 0x67, 0x61, 0x63, 0x79, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, + 0x74, 0x22, 0x1e, 0x0a, 0x1c, 0x4d, 0x73, 0x67, 0x45, 0x78, 0x65, 0x63, 0x4c, 0x65, 0x67, 0x61, + 0x63, 0x79, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x22, 0xe5, 0x01, 0x0a, 0x07, 0x4d, 0x73, 0x67, 0x56, 0x6f, 0x74, 0x65, 0x12, 0x35, 0x0a, + 0x0b, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x04, 0x42, 0x14, 0xea, 0xde, 0x1f, 0x0b, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, + 0x5f, 0x69, 0x64, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x0a, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, + 0x61, 0x6c, 0x49, 0x64, 0x12, 0x2e, 0x0a, 0x05, 0x76, 0x6f, 0x74, 0x65, 0x72, 0x18, 0x02, 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, 0x05, 0x76, + 0x6f, 0x74, 0x65, 0x72, 0x12, 0x31, 0x0a, 0x06, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x0e, 0x32, 0x19, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x67, 0x6f, + 0x76, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x6f, 0x74, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x52, + 0x06, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1a, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, + 0x61, 0x74, 0x61, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, + 0x61, 0x74, 0x61, 0x3a, 0x24, 0x82, 0xe7, 0xb0, 0x2a, 0x05, 0x76, 0x6f, 0x74, 0x65, 0x72, 0x8a, + 0xe7, 0xb0, 0x2a, 0x15, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2d, 0x73, 0x64, 0x6b, 0x2f, 0x76, + 0x31, 0x2f, 0x4d, 0x73, 0x67, 0x56, 0x6f, 0x74, 0x65, 0x22, 0x11, 0x0a, 0x0f, 0x4d, 0x73, 0x67, + 0x56, 0x6f, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xff, 0x01, 0x0a, + 0x0f, 0x4d, 0x73, 0x67, 0x56, 0x6f, 0x74, 0x65, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x65, 0x64, + 0x12, 0x35, 0x0a, 0x0b, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x5f, 0x69, 0x64, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x04, 0x42, 0x14, 0xea, 0xde, 0x1f, 0x0b, 0x70, 0x72, 0x6f, 0x70, 0x6f, + 0x73, 0x61, 0x6c, 0x5f, 0x69, 0x64, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x0a, 0x70, 0x72, 0x6f, + 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x49, 0x64, 0x12, 0x2e, 0x0a, 0x05, 0x76, 0x6f, 0x74, 0x65, 0x72, + 0x18, 0x02, 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, 0x05, 0x76, 0x6f, 0x74, 0x65, 0x72, 0x12, 0x3b, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, + 0x6e, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, + 0x73, 0x2e, 0x67, 0x6f, 0x76, 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x65, + 0x64, 0x56, 0x6f, 0x74, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x07, 0x6f, 0x70, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, + 0x3a, 0x2c, 0x82, 0xe7, 0xb0, 0x2a, 0x05, 0x76, 0x6f, 0x74, 0x65, 0x72, 0x8a, 0xe7, 0xb0, 0x2a, + 0x1d, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2d, 0x73, 0x64, 0x6b, 0x2f, 0x76, 0x31, 0x2f, 0x4d, + 0x73, 0x67, 0x56, 0x6f, 0x74, 0x65, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x65, 0x64, 0x22, 0x19, + 0x0a, 0x17, 0x4d, 0x73, 0x67, 0x56, 0x6f, 0x74, 0x65, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x65, + 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xe6, 0x01, 0x0a, 0x0a, 0x4d, 0x73, + 0x67, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x12, 0x35, 0x0a, 0x0b, 0x70, 0x72, 0x6f, 0x70, + 0x6f, 0x73, 0x61, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x42, 0x14, 0xea, + 0xde, 0x1f, 0x0b, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x5f, 0x69, 0x64, 0xa8, 0xe7, + 0xb0, 0x2a, 0x01, 0x52, 0x0a, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x49, 0x64, 0x12, + 0x36, 0x0a, 0x09, 0x64, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x18, 0x02, 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, 0x09, 0x64, 0x65, + 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x12, 0x3c, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, + 0x74, 0x18, 0x03, 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, 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x06, 0x61, + 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x3a, 0x2b, 0x82, 0xe7, 0xb0, 0x2a, 0x09, 0x64, 0x65, 0x70, 0x6f, + 0x73, 0x69, 0x74, 0x6f, 0x72, 0x8a, 0xe7, 0xb0, 0x2a, 0x18, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, + 0x2d, 0x73, 0x64, 0x6b, 0x2f, 0x76, 0x31, 0x2f, 0x4d, 0x73, 0x67, 0x44, 0x65, 0x70, 0x6f, 0x73, + 0x69, 0x74, 0x22, 0x14, 0x0a, 0x12, 0x4d, 0x73, 0x67, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xbb, 0x01, 0x0a, 0x0f, 0x4d, 0x73, 0x67, + 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x36, 0x0a, 0x09, + 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 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, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, + 0x72, 0x69, 0x74, 0x79, 0x12, 0x38, 0x0a, 0x06, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x67, 0x6f, + 0x76, 0x2e, 0x76, 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, 0x3a, 0x36, + 0x82, 0xe7, 0xb0, 0x2a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x8a, 0xe7, + 0xb0, 0x2a, 0x23, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2d, 0x73, 0x64, 0x6b, 0x2f, 0x78, 0x2f, + 0x67, 0x6f, 0x76, 0x2f, 0x76, 0x31, 0x2f, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, + 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x22, 0x19, 0x0a, 0x17, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, + 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x22, 0x8a, 0x01, 0x0a, 0x11, 0x4d, 0x73, 0x67, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x50, + 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x12, 0x30, 0x0a, 0x0b, 0x70, 0x72, 0x6f, 0x70, 0x6f, + 0x73, 0x61, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x42, 0x0f, 0xea, 0xde, + 0x1f, 0x0b, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x5f, 0x69, 0x64, 0x52, 0x0a, 0x70, + 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x49, 0x64, 0x12, 0x34, 0x0a, 0x08, 0x70, 0x72, 0x6f, + 0x70, 0x6f, 0x73, 0x65, 0x72, 0x18, 0x02, 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, 0x08, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x72, 0x3a, + 0x0d, 0x82, 0xe7, 0xb0, 0x2a, 0x08, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x72, 0x22, 0xc1, + 0x01, 0x0a, 0x19, 0x4d, 0x73, 0x67, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x50, 0x72, 0x6f, 0x70, + 0x6f, 0x73, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x30, 0x0a, 0x0b, + 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x04, 0x42, 0x0f, 0xea, 0xde, 0x1f, 0x0b, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x5f, + 0x69, 0x64, 0x52, 0x0a, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x49, 0x64, 0x12, 0x49, + 0x0a, 0x0d, 0x63, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x65, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, + 0x70, 0x42, 0x08, 0xc8, 0xde, 0x1f, 0x00, 0x90, 0xdf, 0x1f, 0x01, 0x52, 0x0c, 0x63, 0x61, 0x6e, + 0x63, 0x65, 0x6c, 0x65, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x27, 0x0a, 0x0f, 0x63, 0x61, 0x6e, + 0x63, 0x65, 0x6c, 0x65, 0x64, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x04, 0x52, 0x0e, 0x63, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x65, 0x64, 0x48, 0x65, 0x69, 0x67, + 0x68, 0x74, 0x32, 0xe8, 0x04, 0x0a, 0x03, 0x4d, 0x73, 0x67, 0x12, 0x5c, 0x0a, 0x0e, 0x53, 0x75, + 0x62, 0x6d, 0x69, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x12, 0x20, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x67, 0x6f, 0x76, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, - 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x65, 0x0a, 0x11, 0x45, 0x78, 0x65, 0x63, 0x4c, 0x65, - 0x67, 0x61, 0x63, 0x79, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x12, 0x23, 0x2e, 0x63, 0x6f, - 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x67, 0x6f, 0x76, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x45, - 0x78, 0x65, 0x63, 0x4c, 0x65, 0x67, 0x61, 0x63, 0x79, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, - 0x1a, 0x2b, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x67, 0x6f, 0x76, 0x2e, 0x76, 0x31, - 0x2e, 0x4d, 0x73, 0x67, 0x45, 0x78, 0x65, 0x63, 0x4c, 0x65, 0x67, 0x61, 0x63, 0x79, 0x43, 0x6f, - 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3e, 0x0a, - 0x04, 0x56, 0x6f, 0x74, 0x65, 0x12, 0x16, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x67, - 0x6f, 0x76, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x56, 0x6f, 0x74, 0x65, 0x1a, 0x1e, 0x2e, - 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x67, 0x6f, 0x76, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, - 0x67, 0x56, 0x6f, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x56, 0x0a, - 0x0c, 0x56, 0x6f, 0x74, 0x65, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x65, 0x64, 0x12, 0x1e, 0x2e, + 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x1a, 0x28, + 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x67, 0x6f, 0x76, 0x2e, 0x76, 0x31, 0x2e, 0x4d, + 0x73, 0x67, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x65, 0x0a, 0x11, 0x45, 0x78, 0x65, 0x63, + 0x4c, 0x65, 0x67, 0x61, 0x63, 0x79, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x12, 0x23, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x67, 0x6f, 0x76, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, - 0x67, 0x56, 0x6f, 0x74, 0x65, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x65, 0x64, 0x1a, 0x26, 0x2e, + 0x67, 0x45, 0x78, 0x65, 0x63, 0x4c, 0x65, 0x67, 0x61, 0x63, 0x79, 0x43, 0x6f, 0x6e, 0x74, 0x65, + 0x6e, 0x74, 0x1a, 0x2b, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x67, 0x6f, 0x76, 0x2e, + 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x45, 0x78, 0x65, 0x63, 0x4c, 0x65, 0x67, 0x61, 0x63, 0x79, + 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, + 0x3e, 0x0a, 0x04, 0x56, 0x6f, 0x74, 0x65, 0x12, 0x16, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, + 0x2e, 0x67, 0x6f, 0x76, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x56, 0x6f, 0x74, 0x65, 0x1a, + 0x1e, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x67, 0x6f, 0x76, 0x2e, 0x76, 0x31, 0x2e, + 0x4d, 0x73, 0x67, 0x56, 0x6f, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, + 0x56, 0x0a, 0x0c, 0x56, 0x6f, 0x74, 0x65, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x65, 0x64, 0x12, + 0x1e, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x67, 0x6f, 0x76, 0x2e, 0x76, 0x31, 0x2e, + 0x4d, 0x73, 0x67, 0x56, 0x6f, 0x74, 0x65, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x65, 0x64, 0x1a, + 0x26, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x67, 0x6f, 0x76, 0x2e, 0x76, 0x31, 0x2e, + 0x4d, 0x73, 0x67, 0x56, 0x6f, 0x74, 0x65, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x65, 0x64, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x47, 0x0a, 0x07, 0x44, 0x65, 0x70, 0x6f, 0x73, + 0x69, 0x74, 0x12, 0x19, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x67, 0x6f, 0x76, 0x2e, + 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x1a, 0x21, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x67, 0x6f, 0x76, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, - 0x67, 0x56, 0x6f, 0x74, 0x65, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x65, 0x64, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x47, 0x0a, 0x07, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, - 0x12, 0x19, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x67, 0x6f, 0x76, 0x2e, 0x76, 0x31, - 0x2e, 0x4d, 0x73, 0x67, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x1a, 0x21, 0x2e, 0x63, 0x6f, - 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x67, 0x6f, 0x76, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x44, - 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x56, - 0x0a, 0x0c, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x1e, - 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x67, 0x6f, 0x76, 0x2e, 0x76, 0x31, 0x2e, 0x4d, - 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x1a, 0x26, - 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x67, 0x6f, 0x76, 0x2e, 0x76, 0x31, 0x2e, 0x4d, - 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x65, + 0x67, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x12, 0x56, 0x0a, 0x0c, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, + 0x12, 0x1e, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x67, 0x6f, 0x76, 0x2e, 0x76, 0x31, + 0x2e, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, + 0x1a, 0x26, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x67, 0x6f, 0x76, 0x2e, 0x76, 0x31, + 0x2e, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5c, 0x0a, 0x0e, 0x43, 0x61, 0x6e, 0x63, + 0x65, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x12, 0x20, 0x2e, 0x63, 0x6f, 0x73, + 0x6d, 0x6f, 0x73, 0x2e, 0x67, 0x6f, 0x76, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x43, 0x61, + 0x6e, 0x63, 0x65, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x1a, 0x28, 0x2e, 0x63, + 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x67, 0x6f, 0x76, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, + 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x1a, 0x05, 0x80, 0xe7, 0xb0, 0x2a, 0x01, 0x42, 0x98, 0x01, 0x0a, 0x11, 0x63, 0x6f, 0x6d, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x67, 0x6f, 0x76, 0x2e, 0x76, 0x31, 0x42, 0x07, 0x54, 0x78, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x24, @@ -6676,7 +7808,7 @@ func file_cosmos_gov_v1_tx_proto_rawDescGZIP() []byte { return file_cosmos_gov_v1_tx_proto_rawDescData } -var file_cosmos_gov_v1_tx_proto_msgTypes = make([]protoimpl.MessageInfo, 12) +var file_cosmos_gov_v1_tx_proto_msgTypes = make([]protoimpl.MessageInfo, 14) var file_cosmos_gov_v1_tx_proto_goTypes = []interface{}{ (*MsgSubmitProposal)(nil), // 0: cosmos.gov.v1.MsgSubmitProposal (*MsgSubmitProposalResponse)(nil), // 1: cosmos.gov.v1.MsgSubmitProposalResponse @@ -6690,37 +7822,43 @@ var file_cosmos_gov_v1_tx_proto_goTypes = []interface{}{ (*MsgDepositResponse)(nil), // 9: cosmos.gov.v1.MsgDepositResponse (*MsgUpdateParams)(nil), // 10: cosmos.gov.v1.MsgUpdateParams (*MsgUpdateParamsResponse)(nil), // 11: cosmos.gov.v1.MsgUpdateParamsResponse - (*anypb.Any)(nil), // 12: google.protobuf.Any - (*v1beta1.Coin)(nil), // 13: cosmos.base.v1beta1.Coin - (VoteOption)(0), // 14: cosmos.gov.v1.VoteOption - (*WeightedVoteOption)(nil), // 15: cosmos.gov.v1.WeightedVoteOption - (*Params)(nil), // 16: cosmos.gov.v1.Params + (*MsgCancelProposal)(nil), // 12: cosmos.gov.v1.MsgCancelProposal + (*MsgCancelProposalResponse)(nil), // 13: cosmos.gov.v1.MsgCancelProposalResponse + (*anypb.Any)(nil), // 14: google.protobuf.Any + (*v1beta1.Coin)(nil), // 15: cosmos.base.v1beta1.Coin + (VoteOption)(0), // 16: cosmos.gov.v1.VoteOption + (*WeightedVoteOption)(nil), // 17: cosmos.gov.v1.WeightedVoteOption + (*Params)(nil), // 18: cosmos.gov.v1.Params + (*timestamppb.Timestamp)(nil), // 19: google.protobuf.Timestamp } var file_cosmos_gov_v1_tx_proto_depIdxs = []int32{ - 12, // 0: cosmos.gov.v1.MsgSubmitProposal.messages:type_name -> google.protobuf.Any - 13, // 1: cosmos.gov.v1.MsgSubmitProposal.initial_deposit:type_name -> cosmos.base.v1beta1.Coin - 12, // 2: cosmos.gov.v1.MsgExecLegacyContent.content:type_name -> google.protobuf.Any - 14, // 3: cosmos.gov.v1.MsgVote.option:type_name -> cosmos.gov.v1.VoteOption - 15, // 4: cosmos.gov.v1.MsgVoteWeighted.options:type_name -> cosmos.gov.v1.WeightedVoteOption - 13, // 5: cosmos.gov.v1.MsgDeposit.amount:type_name -> cosmos.base.v1beta1.Coin - 16, // 6: cosmos.gov.v1.MsgUpdateParams.params:type_name -> cosmos.gov.v1.Params - 0, // 7: cosmos.gov.v1.Msg.SubmitProposal:input_type -> cosmos.gov.v1.MsgSubmitProposal - 2, // 8: cosmos.gov.v1.Msg.ExecLegacyContent:input_type -> cosmos.gov.v1.MsgExecLegacyContent - 4, // 9: cosmos.gov.v1.Msg.Vote:input_type -> cosmos.gov.v1.MsgVote - 6, // 10: cosmos.gov.v1.Msg.VoteWeighted:input_type -> cosmos.gov.v1.MsgVoteWeighted - 8, // 11: cosmos.gov.v1.Msg.Deposit:input_type -> cosmos.gov.v1.MsgDeposit - 10, // 12: cosmos.gov.v1.Msg.UpdateParams:input_type -> cosmos.gov.v1.MsgUpdateParams - 1, // 13: cosmos.gov.v1.Msg.SubmitProposal:output_type -> cosmos.gov.v1.MsgSubmitProposalResponse - 3, // 14: cosmos.gov.v1.Msg.ExecLegacyContent:output_type -> cosmos.gov.v1.MsgExecLegacyContentResponse - 5, // 15: cosmos.gov.v1.Msg.Vote:output_type -> cosmos.gov.v1.MsgVoteResponse - 7, // 16: cosmos.gov.v1.Msg.VoteWeighted:output_type -> cosmos.gov.v1.MsgVoteWeightedResponse - 9, // 17: cosmos.gov.v1.Msg.Deposit:output_type -> cosmos.gov.v1.MsgDepositResponse - 11, // 18: cosmos.gov.v1.Msg.UpdateParams:output_type -> cosmos.gov.v1.MsgUpdateParamsResponse - 13, // [13:19] is the sub-list for method output_type - 7, // [7:13] is the sub-list for method input_type - 7, // [7:7] is the sub-list for extension type_name - 7, // [7:7] is the sub-list for extension extendee - 0, // [0:7] is the sub-list for field type_name + 14, // 0: cosmos.gov.v1.MsgSubmitProposal.messages:type_name -> google.protobuf.Any + 15, // 1: cosmos.gov.v1.MsgSubmitProposal.initial_deposit:type_name -> cosmos.base.v1beta1.Coin + 14, // 2: cosmos.gov.v1.MsgExecLegacyContent.content:type_name -> google.protobuf.Any + 16, // 3: cosmos.gov.v1.MsgVote.option:type_name -> cosmos.gov.v1.VoteOption + 17, // 4: cosmos.gov.v1.MsgVoteWeighted.options:type_name -> cosmos.gov.v1.WeightedVoteOption + 15, // 5: cosmos.gov.v1.MsgDeposit.amount:type_name -> cosmos.base.v1beta1.Coin + 18, // 6: cosmos.gov.v1.MsgUpdateParams.params:type_name -> cosmos.gov.v1.Params + 19, // 7: cosmos.gov.v1.MsgCancelProposalResponse.canceled_time:type_name -> google.protobuf.Timestamp + 0, // 8: cosmos.gov.v1.Msg.SubmitProposal:input_type -> cosmos.gov.v1.MsgSubmitProposal + 2, // 9: cosmos.gov.v1.Msg.ExecLegacyContent:input_type -> cosmos.gov.v1.MsgExecLegacyContent + 4, // 10: cosmos.gov.v1.Msg.Vote:input_type -> cosmos.gov.v1.MsgVote + 6, // 11: cosmos.gov.v1.Msg.VoteWeighted:input_type -> cosmos.gov.v1.MsgVoteWeighted + 8, // 12: cosmos.gov.v1.Msg.Deposit:input_type -> cosmos.gov.v1.MsgDeposit + 10, // 13: cosmos.gov.v1.Msg.UpdateParams:input_type -> cosmos.gov.v1.MsgUpdateParams + 12, // 14: cosmos.gov.v1.Msg.CancelProposal:input_type -> cosmos.gov.v1.MsgCancelProposal + 1, // 15: cosmos.gov.v1.Msg.SubmitProposal:output_type -> cosmos.gov.v1.MsgSubmitProposalResponse + 3, // 16: cosmos.gov.v1.Msg.ExecLegacyContent:output_type -> cosmos.gov.v1.MsgExecLegacyContentResponse + 5, // 17: cosmos.gov.v1.Msg.Vote:output_type -> cosmos.gov.v1.MsgVoteResponse + 7, // 18: cosmos.gov.v1.Msg.VoteWeighted:output_type -> cosmos.gov.v1.MsgVoteWeightedResponse + 9, // 19: cosmos.gov.v1.Msg.Deposit:output_type -> cosmos.gov.v1.MsgDepositResponse + 11, // 20: cosmos.gov.v1.Msg.UpdateParams:output_type -> cosmos.gov.v1.MsgUpdateParamsResponse + 13, // 21: cosmos.gov.v1.Msg.CancelProposal:output_type -> cosmos.gov.v1.MsgCancelProposalResponse + 15, // [15:22] is the sub-list for method output_type + 8, // [8:15] is the sub-list for method input_type + 8, // [8:8] is the sub-list for extension type_name + 8, // [8:8] is the sub-list for extension extendee + 0, // [0:8] is the sub-list for field type_name } func init() { file_cosmos_gov_v1_tx_proto_init() } @@ -6874,6 +8012,30 @@ func file_cosmos_gov_v1_tx_proto_init() { return nil } } + file_cosmos_gov_v1_tx_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MsgCancelProposal); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cosmos_gov_v1_tx_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MsgCancelProposalResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } } type x struct{} out := protoimpl.TypeBuilder{ @@ -6881,7 +8043,7 @@ func file_cosmos_gov_v1_tx_proto_init() { GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: file_cosmos_gov_v1_tx_proto_rawDesc, NumEnums: 0, - NumMessages: 12, + NumMessages: 14, NumExtensions: 0, NumServices: 1, }, diff --git a/api/cosmos/gov/v1/tx_grpc.pb.go b/api/cosmos/gov/v1/tx_grpc.pb.go index e72e0c6a273..8c97f426131 100644 --- a/api/cosmos/gov/v1/tx_grpc.pb.go +++ b/api/cosmos/gov/v1/tx_grpc.pb.go @@ -38,6 +38,10 @@ type MsgClient interface { // // Since: cosmos-sdk 0.47 UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error) + // CancelProposal defines a method to cancel governance proposal + // + // Since: cosmos-sdk 0.48 + CancelProposal(ctx context.Context, in *MsgCancelProposal, opts ...grpc.CallOption) (*MsgCancelProposalResponse, error) } type msgClient struct { @@ -102,6 +106,15 @@ func (c *msgClient) UpdateParams(ctx context.Context, in *MsgUpdateParams, opts return out, nil } +func (c *msgClient) CancelProposal(ctx context.Context, in *MsgCancelProposal, opts ...grpc.CallOption) (*MsgCancelProposalResponse, error) { + out := new(MsgCancelProposalResponse) + err := c.cc.Invoke(ctx, "/cosmos.gov.v1.Msg/CancelProposal", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + // MsgServer is the server API for Msg service. // All implementations must embed UnimplementedMsgServer // for forward compatibility @@ -122,6 +135,10 @@ type MsgServer interface { // // Since: cosmos-sdk 0.47 UpdateParams(context.Context, *MsgUpdateParams) (*MsgUpdateParamsResponse, error) + // CancelProposal defines a method to cancel governance proposal + // + // Since: cosmos-sdk 0.48 + CancelProposal(context.Context, *MsgCancelProposal) (*MsgCancelProposalResponse, error) mustEmbedUnimplementedMsgServer() } @@ -147,6 +164,9 @@ func (UnimplementedMsgServer) Deposit(context.Context, *MsgDeposit) (*MsgDeposit func (UnimplementedMsgServer) UpdateParams(context.Context, *MsgUpdateParams) (*MsgUpdateParamsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method UpdateParams not implemented") } +func (UnimplementedMsgServer) CancelProposal(context.Context, *MsgCancelProposal) (*MsgCancelProposalResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method CancelProposal not implemented") +} func (UnimplementedMsgServer) mustEmbedUnimplementedMsgServer() {} // UnsafeMsgServer may be embedded to opt out of forward compatibility for this service. @@ -268,6 +288,24 @@ func _Msg_UpdateParams_Handler(srv interface{}, ctx context.Context, dec func(in return interceptor(ctx, in, info, handler) } +func _Msg_CancelProposal_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgCancelProposal) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).CancelProposal(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmos.gov.v1.Msg/CancelProposal", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).CancelProposal(ctx, req.(*MsgCancelProposal)) + } + return interceptor(ctx, in, info, handler) +} + // Msg_ServiceDesc is the grpc.ServiceDesc for Msg service. // It's only intended for direct use with grpc.RegisterService, // and not to be introspected or modified (even as a copy) @@ -299,6 +337,10 @@ var Msg_ServiceDesc = grpc.ServiceDesc{ MethodName: "UpdateParams", Handler: _Msg_UpdateParams_Handler, }, + { + MethodName: "CancelProposal", + Handler: _Msg_CancelProposal_Handler, + }, }, Streams: []grpc.StreamDesc{}, Metadata: "cosmos/gov/v1/tx.proto", diff --git a/proto/cosmos/gov/v1/gov.proto b/proto/cosmos/gov/v1/gov.proto index 1f8c1413754..482f639ad45 100644 --- a/proto/cosmos/gov/v1/gov.proto +++ b/proto/cosmos/gov/v1/gov.proto @@ -208,4 +208,15 @@ message Params { // The ratio representing the proportion of the deposit value that must be paid at proposal submission. string min_initial_deposit_ratio = 7 [(cosmos_proto.scalar) = "cosmos.Dec"]; + + // The cancel ratio which will not be returned back to the depositors when a proposal is cancelled. + // + // Since: cosmos-sdk 0.48 + string proposal_cancel_ratio = 8 [(cosmos_proto.scalar) = "cosmos.Dec"]; + + // The address which will receive (proposal_cancel_ratio * deposit) proposal deposits. + // If empty, the (proposal_cancel_ratio * deposit) proposal deposits will be burned. + // + // Since: cosmos-sdk 0.48 + string proposal_cancel_dest = 9 [(cosmos_proto.scalar) = "cosmos.AddressString"]; } diff --git a/proto/cosmos/gov/v1/tx.proto b/proto/cosmos/gov/v1/tx.proto index 969eeff69f0..e0cd9128440 100644 --- a/proto/cosmos/gov/v1/tx.proto +++ b/proto/cosmos/gov/v1/tx.proto @@ -9,6 +9,7 @@ import "cosmos_proto/cosmos.proto"; import "google/protobuf/any.proto"; import "cosmos/msg/v1/msg.proto"; import "amino/amino.proto"; +import "google/protobuf/timestamp.proto"; option go_package = "github.com/cosmos/cosmos-sdk/x/gov/types/v1"; @@ -37,6 +38,11 @@ service Msg { // // Since: cosmos-sdk 0.47 rpc UpdateParams(MsgUpdateParams) returns (MsgUpdateParamsResponse); + + // CancelProposal defines a method to cancel governance proposal + // + // Since: cosmos-sdk 0.48 + rpc CancelProposal(MsgCancelProposal) returns (MsgCancelProposalResponse); } // MsgSubmitProposal defines an sdk.Msg type that supports submitting arbitrary @@ -170,3 +176,25 @@ message MsgUpdateParams { // // Since: cosmos-sdk 0.47 message MsgUpdateParamsResponse {} + +// MsgCancelProposal is the Msg/CancelProposal request type. +// +// Since: cosmos-sdk 0.48 +message MsgCancelProposal { + option (cosmos.msg.v1.signer) = "proposer"; + + uint64 proposal_id = 1 [(gogoproto.jsontag) = "proposal_id"]; + string proposer = 2 [(cosmos_proto.scalar) = "cosmos.AddressString"]; +} + +// MsgCancelProposalResponse defines the response structure for executing a +// MsgCancelProposal message. +// +// Since: cosmos-sdk 0.48 +message MsgCancelProposalResponse { + uint64 proposal_id = 1 [(gogoproto.jsontag) = "proposal_id"]; + // canceled_time is the time when proposal is canceled. + google.protobuf.Timestamp canceled_time = 2 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false]; + // canceled_height defines the block height at which the proposal is canceled. + uint64 canceled_height = 3; +} diff --git a/simapp/app.go b/simapp/app.go index 8a8819a84ce..2f94aecb343 100644 --- a/simapp/app.go +++ b/simapp/app.go @@ -357,7 +357,7 @@ func NewSimApp( */ govKeeper := govkeeper.NewKeeper( appCodec, keys[govtypes.StoreKey], app.AccountKeeper, app.BankKeeper, - app.StakingKeeper, app.MsgServiceRouter(), govConfig, authtypes.NewModuleAddress(govtypes.ModuleName).String(), + app.StakingKeeper, app.DistrKeeper, app.MsgServiceRouter(), govConfig, authtypes.NewModuleAddress(govtypes.ModuleName).String(), ) // Set legacy router for backwards compatibility with gov v1beta1 diff --git a/simapp/upgrades.go b/simapp/upgrades.go index 1324d9d98e8..d92a9dbd7da 100644 --- a/simapp/upgrades.go +++ b/simapp/upgrades.go @@ -27,6 +27,9 @@ func (app SimApp) RegisterUpgradeHandlers() { // dedicated x/consensus module. baseapp.MigrateParams(ctx, baseAppLegacySS, &app.ConsensusParamsKeeper) + // Note: this migration is optional, + // You can include x/gov proposal migration documented at [UPGRADING.md](https://github.com/cosmos/cosmos-sdk/blob/main/UPGRADING.md) + return app.ModuleManager.RunMigrations(ctx, app.Configurator(), fromVM) }, ) diff --git a/tests/e2e/client/grpc/tmservice/service_test.go b/tests/e2e/client/grpc/tmservice/service_test.go index 65a48ea97db..a3e6f2f9fb3 100644 --- a/tests/e2e/client/grpc/tmservice/service_test.go +++ b/tests/e2e/client/grpc/tmservice/service_test.go @@ -19,6 +19,7 @@ import ( "github.com/cosmos/cosmos-sdk/types" qtypes "github.com/cosmos/cosmos-sdk/types/query" "github.com/cosmos/cosmos-sdk/version" + _ "github.com/cosmos/cosmos-sdk/x/distribution" _ "github.com/cosmos/cosmos-sdk/x/gov" ) diff --git a/tests/e2e/gov/grpc.go b/tests/e2e/gov/grpc.go index 8a8f8266a37..633281b38ca 100644 --- a/tests/e2e/gov/grpc.go +++ b/tests/e2e/gov/grpc.go @@ -77,7 +77,7 @@ func (s *E2ETestSuite) TestGetProposalsGRPC() { "valid request", fmt.Sprintf("%s/cosmos/gov/v1/proposals", val.APIAddress), map[string]string{}, - 3, + 4, false, }, { diff --git a/tests/e2e/gov/query.go b/tests/e2e/gov/query.go index 884d13da046..135ad334186 100644 --- a/tests/e2e/gov/query.go +++ b/tests/e2e/gov/query.go @@ -23,7 +23,7 @@ func (s *E2ETestSuite) TestCmdParams() { { "json output", []string{fmt.Sprintf("--%s=json", flags.FlagOutput)}, - `{"voting_params":{"voting_period":"172800s"},"deposit_params":{"min_deposit":[{"denom":"stake","amount":"10000000"}],"max_deposit_period":"172800s"},"tally_params":{"quorum":"0.334000000000000000","threshold":"0.500000000000000000","veto_threshold":"0.334000000000000000"},"params":{"min_deposit":[{"denom":"stake","amount":"10000000"}],"max_deposit_period":"172800s","voting_period":"172800s","quorum":"0.334000000000000000","threshold":"0.500000000000000000","veto_threshold":"0.334000000000000000","min_initial_deposit_ratio":"0.000000000000000000"}}`, + `{"voting_params":{"voting_period":"172800s"},"deposit_params":{"min_deposit":[{"denom":"stake","amount":"10000000"}],"max_deposit_period":"172800s"},"tally_params":{"quorum":"0.334000000000000000","threshold":"0.500000000000000000","veto_threshold":"0.334000000000000000"},"params":{"min_deposit":[{"denom":"stake","amount":"10000000"}],"max_deposit_period":"172800s","voting_period":"172800s","quorum":"0.334000000000000000","threshold":"0.500000000000000000","veto_threshold":"0.334000000000000000","min_initial_deposit_ratio":"0.000000000000000000","proposal_cancel_ratio":"0.500000000000000000","proposal_cancel_dest":""}}`, }, { "text output", @@ -40,6 +40,8 @@ params: - amount: "10000000" denom: stake min_initial_deposit_ratio: "0.000000000000000000" + proposal_cancel_dest: "" + proposal_cancel_ratio: "0.500000000000000000" quorum: "0.334000000000000000" threshold: "0.500000000000000000" veto_threshold: "0.334000000000000000" @@ -306,7 +308,7 @@ func (s *E2ETestSuite) TestCmdGetProposals() { var proposals v1.QueryProposalsResponse s.Require().NoError(clientCtx.Codec.UnmarshalJSON(out.Bytes(), &proposals), out.String()) - s.Require().Len(proposals.Proposals, 3) + s.Require().Greater(len(proposals.Proposals), 0) } }) } diff --git a/tests/e2e/gov/tx.go b/tests/e2e/gov/tx.go index 6a5cf913ba7..a8e06691133 100644 --- a/tests/e2e/gov/tx.go +++ b/tests/e2e/gov/tx.go @@ -14,6 +14,7 @@ import ( "github.com/cosmos/cosmos-sdk/testutil/network" sdk "github.com/cosmos/cosmos-sdk/types" authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" + banktypes "github.com/cosmos/cosmos-sdk/x/bank/types" "github.com/cosmos/cosmos-sdk/x/gov/client/cli" govclitestutil "github.com/cosmos/cosmos-sdk/x/gov/client/testutil" "github.com/cosmos/cosmos-sdk/x/gov/types" @@ -41,36 +42,51 @@ func (s *E2ETestSuite) SetupSuite() { s.Require().NoError(s.network.WaitForNextBlock()) val := s.network.Validators[0] + clientCtx := val.ClientCtx + var resp sdk.TxResponse // create a proposal with deposit - _, err = govclitestutil.MsgSubmitLegacyProposal(val.ClientCtx, val.Address.String(), + out, err := govclitestutil.MsgSubmitLegacyProposal(val.ClientCtx, val.Address.String(), "Text Proposal 1", "Where is the title!?", v1beta1.ProposalTypeText, fmt.Sprintf("--%s=%s", cli.FlagDeposit, sdk.NewCoin(s.cfg.BondDenom, v1.DefaultMinDepositTokens).String())) s.Require().NoError(err) - s.Require().NoError(s.network.WaitForNextBlock()) + s.Require().NoError(clientCtx.Codec.UnmarshalJSON(out.Bytes(), &resp), out.String()) + s.Require().NoError(clitestutil.CheckTxCode(s.network, clientCtx, resp.TxHash, 0)) // vote for proposal - _, err = govclitestutil.MsgVote(val.ClientCtx, val.Address.String(), "1", "yes") + out, err = govclitestutil.MsgVote(val.ClientCtx, val.Address.String(), "1", "yes") s.Require().NoError(err) - s.Require().NoError(s.network.WaitForNextBlock()) + s.Require().NoError(clientCtx.Codec.UnmarshalJSON(out.Bytes(), &resp), out.String()) + s.Require().NoError(clitestutil.CheckTxCode(s.network, clientCtx, resp.TxHash, 0)) // create a proposal without deposit - _, err = govclitestutil.MsgSubmitLegacyProposal(val.ClientCtx, val.Address.String(), + out, err = govclitestutil.MsgSubmitLegacyProposal(val.ClientCtx, val.Address.String(), "Text Proposal 2", "Where is the title!?", v1beta1.ProposalTypeText) s.Require().NoError(err) - s.Require().NoError(s.network.WaitForNextBlock()) + s.Require().NoError(clientCtx.Codec.UnmarshalJSON(out.Bytes(), &resp), out.String()) + s.Require().NoError(clitestutil.CheckTxCode(s.network, clientCtx, resp.TxHash, 0)) // create a proposal3 with deposit - _, err = govclitestutil.MsgSubmitLegacyProposal(val.ClientCtx, val.Address.String(), + out, err = govclitestutil.MsgSubmitLegacyProposal(val.ClientCtx, val.Address.String(), "Text Proposal 3", "Where is the title!?", v1beta1.ProposalTypeText, fmt.Sprintf("--%s=%s", cli.FlagDeposit, sdk.NewCoin(s.cfg.BondDenom, v1.DefaultMinDepositTokens).String())) s.Require().NoError(err) - s.Require().NoError(s.network.WaitForNextBlock()) + s.Require().NoError(clientCtx.Codec.UnmarshalJSON(out.Bytes(), &resp), out.String()) + s.Require().NoError(clitestutil.CheckTxCode(s.network, clientCtx, resp.TxHash, 0)) + + // create a proposal4 with deposit to check the cancel proposal cli tx + out, err = govclitestutil.MsgSubmitLegacyProposal(val.ClientCtx, val.Address.String(), + "Text Proposal 4", "Where is the title!?", v1beta1.ProposalTypeText, + fmt.Sprintf("--%s=%s", cli.FlagDeposit, sdk.NewCoin(s.cfg.BondDenom, v1.DefaultMinDepositTokens).String())) + s.Require().NoError(err) + s.Require().NoError(clientCtx.Codec.UnmarshalJSON(out.Bytes(), &resp), out.String()) + s.Require().NoError(clitestutil.CheckTxCode(s.network, clientCtx, resp.TxHash, 0)) // vote for proposal3 as val - _, err = govclitestutil.MsgVote(val.ClientCtx, val.Address.String(), "3", "yes=0.6,no=0.3,abstain=0.05,no_with_veto=0.05") + out, err = govclitestutil.MsgVote(val.ClientCtx, val.Address.String(), "3", "yes=0.6,no=0.3,abstain=0.05,no_with_veto=0.05") s.Require().NoError(err) - s.Require().NoError(s.network.WaitForNextBlock()) + s.Require().NoError(clientCtx.Codec.UnmarshalJSON(out.Bytes(), &resp), out.String()) + s.Require().NoError(clitestutil.CheckTxCode(s.network, clientCtx, resp.TxHash, 0)) } func (s *E2ETestSuite) TearDownSuite() { @@ -260,6 +276,118 @@ func (s *E2ETestSuite) TestNewCmdSubmitLegacyProposal() { } } +func (s *E2ETestSuite) TestNewCmdCancelProposal() { + val := s.network.Validators[0] + val2 := sdk.AccAddress("invalid_acc_addr") + + testCases := []struct { + name string + args []string + expectErr bool + expectedCode uint32 + }{ + { + "without proposal id", + []string{ + fmt.Sprintf("--%s=%s", flags.FlagFrom, val.Address.String()), + fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation), + fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastSync), + fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10))).String()), + }, + true, 0, + }, + { + "invalid proposal id", + []string{ + "asdasd", + fmt.Sprintf("--%s=%s", flags.FlagFrom, val.Address.String()), + fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation), + fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastSync), + fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10))).String()), + }, + true, 0, + }, + { + "valid proposal-id but invalid proposer", + []string{ + "4", + fmt.Sprintf("--%s=%s", flags.FlagFrom, val2), + fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation), + fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastSync), + fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10))).String()), + }, + true, 0, + }, + { + "valid proposer", + []string{ + "4", + fmt.Sprintf("--%s=%s", flags.FlagFrom, val.Address.String()), + fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation), + fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastSync), + fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10))).String()), + }, + false, 0, + }, + { + "proposal not exists after cancel", + []string{ + "4", + fmt.Sprintf("--%s=%s", flags.FlagFrom, val.Address.String()), + fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation), + fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastSync), + fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10))).String()), + }, + false, 17, + }, + } + + for _, tc := range testCases { + var resp sdk.TxResponse + + s.Run(tc.name, func() { + cmd := cli.NewCmdCancelProposal() + clientCtx := val.ClientCtx + var balRes banktypes.QueryAllBalancesResponse + var newBalance banktypes.QueryAllBalancesResponse + if !tc.expectErr && tc.expectedCode == 0 { + resp, err := clitestutil.QueryBalancesExec(clientCtx, val.Address) + s.Require().NoError(err) + err = val.ClientCtx.Codec.UnmarshalJSON(resp.Bytes(), &balRes) + s.Require().NoError(err) + } + + out, err := clitestutil.ExecTestCLICmd(clientCtx, cmd, tc.args) + if tc.expectErr { + s.Require().Error(err) + } else { + s.Require().NoError(err) + + s.Require().NoError(clientCtx.Codec.UnmarshalJSON(out.Bytes(), &resp), out.String()) + s.Require().NoError(clitestutil.CheckTxCode(s.network, clientCtx, resp.TxHash, tc.expectedCode)) + + if !tc.expectErr && tc.expectedCode == 0 { + resp, err := clitestutil.QueryBalancesExec(clientCtx, val.Address) + s.Require().NoError(err) + err = val.ClientCtx.Codec.UnmarshalJSON(resp.Bytes(), &newBalance) + s.Require().NoError(err) + remainingAmount := v1.DefaultMinDepositTokens.Mul( + v1.DefaultProposalCancelRatio.Mul(sdk.MustNewDecFromStr("100")).TruncateInt(), + ).Quo(sdk.NewIntFromUint64(100)) + + // new balance = old balance + remaining amount from proposal deposit - txFee (cancel proposal) + txFee := sdk.NewInt(10) + s.Require().True( + newBalance.Balances.AmountOf(s.network.Config.BondDenom).Equal( + balRes.Balances.AmountOf(s.network.Config.BondDenom).Add(remainingAmount).Sub(txFee), + ), + ) + } + } + }) + } +} + func (s *E2ETestSuite) TestNewCmdDeposit() { val := s.network.Validators[0] diff --git a/tests/integration/gov/genesis_test.go b/tests/integration/gov/genesis_test.go index f29a6f88ab7..69edb073468 100644 --- a/tests/integration/gov/genesis_test.go +++ b/tests/integration/gov/genesis_test.go @@ -22,7 +22,7 @@ import ( _ "github.com/cosmos/cosmos-sdk/x/consensus" _ "github.com/cosmos/cosmos-sdk/x/distribution" distrkeeper "github.com/cosmos/cosmos-sdk/x/distribution/keeper" - distributiontypes "github.com/cosmos/cosmos-sdk/x/distribution/types" + disttypes "github.com/cosmos/cosmos-sdk/x/distribution/types" "github.com/cosmos/cosmos-sdk/x/gov" "github.com/cosmos/cosmos-sdk/x/gov/keeper" "github.com/cosmos/cosmos-sdk/x/gov/types" @@ -106,7 +106,7 @@ func TestImportExportQueues(t *testing.T) { genesisState[banktypes.ModuleName] = s1.cdc.MustMarshalJSON(bankGenState) genesisState[types.ModuleName] = s1.cdc.MustMarshalJSON(govGenState) genesisState[stakingtypes.ModuleName] = s1.cdc.MustMarshalJSON(stakingGenState) - genesisState[distributiontypes.ModuleName] = s1.cdc.MustMarshalJSON(distributionGenState) + genesisState[disttypes.ModuleName] = s1.cdc.MustMarshalJSON(distributionGenState) stateBytes, err := json.MarshalIndent(genesisState, "", " ") assert.NilError(t, err) diff --git a/tests/integration/gov/module_test.go b/tests/integration/gov/module_test.go index a3fc2eb5e84..c02bdf457da 100644 --- a/tests/integration/gov/module_test.go +++ b/tests/integration/gov/module_test.go @@ -10,6 +10,7 @@ import ( simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims" authkeeper "github.com/cosmos/cosmos-sdk/x/auth/keeper" authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" + _ "github.com/cosmos/cosmos-sdk/x/distribution" "github.com/cosmos/cosmos-sdk/x/gov/types" _ "github.com/cosmos/cosmos-sdk/x/mint" ) @@ -23,6 +24,7 @@ func TestItCreatesModuleAccountOnInitBlock(t *testing.T) { configurator.StakingModule(), configurator.BankModule(), configurator.GovModule(), + configurator.DistributionModule(), configurator.ConsensusModule(), ), &accountKeeper, diff --git a/x/bank/app_test.go b/x/bank/app_test.go index 4ae31ebca74..ac177fd9e7b 100644 --- a/x/bank/app_test.go +++ b/x/bank/app_test.go @@ -22,6 +22,8 @@ import ( "github.com/cosmos/cosmos-sdk/x/bank/testutil" "github.com/cosmos/cosmos-sdk/x/bank/types" _ "github.com/cosmos/cosmos-sdk/x/consensus" + _ "github.com/cosmos/cosmos-sdk/x/distribution" + distrkeeper "github.com/cosmos/cosmos-sdk/x/distribution/keeper" _ "github.com/cosmos/cosmos-sdk/x/gov" govv1 "github.com/cosmos/cosmos-sdk/x/gov/types/v1" _ "github.com/cosmos/cosmos-sdk/x/params" @@ -89,9 +91,10 @@ var ( ) type suite struct { - BankKeeper bankkeeper.Keeper - AccountKeeper types.AccountKeeper - App *runtime.App + BankKeeper bankkeeper.Keeper + AccountKeeper types.AccountKeeper + DistributionKeeper distrkeeper.Keeper + App *runtime.App } func createTestSuite(t *testing.T, genesisAccounts []authtypes.GenesisAccount) suite { @@ -113,8 +116,9 @@ func createTestSuite(t *testing.T, genesisAccounts []authtypes.GenesisAccount) s configurator.ConsensusModule(), configurator.BankModule(), configurator.GovModule(), + configurator.DistributionModule(), ), - startupCfg, &res.BankKeeper, &res.AccountKeeper) + startupCfg, &res.BankKeeper, &res.AccountKeeper, &res.DistributionKeeper) res.App = app diff --git a/x/bank/simulation/operations.go b/x/bank/simulation/operations.go index 29d0b07df6e..7818ebf1a2b 100644 --- a/x/bank/simulation/operations.go +++ b/x/bank/simulation/operations.go @@ -12,7 +12,7 @@ import ( simtypes "github.com/cosmos/cosmos-sdk/types/simulation" "github.com/cosmos/cosmos-sdk/x/bank/keeper" "github.com/cosmos/cosmos-sdk/x/bank/types" - distributiontypes "github.com/cosmos/cosmos-sdk/x/distribution/types" + disttypes "github.com/cosmos/cosmos-sdk/x/distribution/types" "github.com/cosmos/cosmos-sdk/x/simulation" ) @@ -402,7 +402,7 @@ func getModuleAccounts(ak types.AccountKeeper, ctx sdk.Context, moduleAccCount i moduleAccounts := make([]simtypes.Account, moduleAccCount) for i := 0; i < moduleAccCount; i++ { - acc := ak.GetModuleAccount(ctx, distributiontypes.ModuleName) + acc := ak.GetModuleAccount(ctx, disttypes.ModuleName) mAcc := simtypes.Account{ Address: acc.GetAddress(), PrivKey: nil, diff --git a/x/gov/README.md b/x/gov/README.md index 73ef1fe4881..803a1e7b5d3 100644 --- a/x/gov/README.md +++ b/x/gov/README.md @@ -862,16 +862,27 @@ Example Output: ```bash deposit_params: - max_deposit_period: "172800000000000" + max_deposit_period: 172800s min_deposit: - amount: "10000000" denom: stake +params: + max_deposit_period: 172800s + min_deposit: + - amount: "10000000" + denom: stake + min_initial_deposit_ratio: "0.000000000000000000" + proposal_cancel_burn_rate: "0.500000000000000000" + quorum: "0.334000000000000000" + threshold: "0.500000000000000000" + veto_threshold: "0.334000000000000000" + voting_period: 172800s tally_params: quorum: "0.334000000000000000" threshold: "0.500000000000000000" veto_threshold: "0.334000000000000000" voting_params: - voting_period: "172800000000000" + voting_period: 172800s ``` ##### proposal @@ -1213,6 +1224,19 @@ Example (`software-upgrade`): simd tx gov submit-legacy-proposal software-upgrade v2 --title="Test Proposal" --description="testing, testing, 1, 2, 3" --upgrade-height 1000000 --from cosmos1.. ``` +#### cancel-proposal + +Once proposal is canceled, from the deposits of proposal `deposits * proposal_cancel_ratio` will be burned or sent to `ProposalCancelDest` address , if `ProposalCancelDest` is empty then deposits will be burned. The `remaining deposits` will be sent to depositers. + +```bash +simd tx gov cancel-proposal [proposal-id] [flags] +``` + +Example: +```bash +simd tx gov cancel-proposal 1 --from cosmos1... +``` + ##### vote The `vote` command allows users to submit a vote for a given governance proposal. diff --git a/x/gov/abci.go b/x/gov/abci.go index a19762be44b..3135e7abb15 100644 --- a/x/gov/abci.go +++ b/x/gov/abci.go @@ -15,8 +15,7 @@ import ( func EndBlocker(ctx sdk.Context, keeper *keeper.Keeper) { defer telemetry.ModuleMeasureSince(types.ModuleName, time.Now(), telemetry.MetricKeyEndBlocker) - logger := keeper.Logger(ctx) - + logger := ctx.Logger().With("module", "x/"+types.ModuleName) // delete dead proposals from store and returns theirs deposits. // A proposal is dead when it's inactive and didn't get enough deposit on time to get into voting phase. keeper.IterateInactiveProposalsQueue(ctx, ctx.BlockHeader().Time, func(proposal v1.Proposal) bool { diff --git a/x/gov/abci_test.go b/x/gov/abci_test.go index fbb523f0b0d..f58b86daccb 100644 --- a/x/gov/abci_test.go +++ b/x/gov/abci_test.go @@ -299,6 +299,7 @@ func TestProposalPassedEndblocker(t *testing.T) { app.BeginBlock(abci.RequestBeginBlock{Header: header}) valAddr := sdk.ValAddress(addrs[0]) + proposer := addrs[0] createValidators(t, stakingMsgSvr, ctx, []sdk.ValAddress{valAddr}, []int64{10}) staking.EndBlocker(ctx, suite.StakingKeeper) @@ -307,7 +308,7 @@ func TestProposalPassedEndblocker(t *testing.T) { require.NotNil(t, macc) initialModuleAccCoins := suite.BankKeeper.GetAllBalances(ctx, macc.GetAddress()) - proposal, err := suite.GovKeeper.SubmitProposal(ctx, []sdk.Msg{mkTestLegacyContent(t)}, "", "title", "summary", addrs[0]) + proposal, err := suite.GovKeeper.SubmitProposal(ctx, []sdk.Msg{mkTestLegacyContent(t)}, "", "title", "summary", proposer) require.NoError(t, err) proposalCoins := sdk.Coins{sdk.NewCoin(sdk.DefaultBondDenom, suite.StakingKeeper.TokensFromConsensusPower(ctx, 10))} @@ -351,12 +352,13 @@ func TestEndBlockerProposalHandlerFailed(t *testing.T) { app.BeginBlock(abci.RequestBeginBlock{Header: header}) valAddr := sdk.ValAddress(addrs[0]) + proposer := addrs[0] createValidators(t, stakingMsgSvr, ctx, []sdk.ValAddress{valAddr}, []int64{10}) staking.EndBlocker(ctx, suite.StakingKeeper) msg := banktypes.NewMsgSend(authtypes.NewModuleAddress(types.ModuleName), addrs[0], sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(100000)))) - proposal, err := suite.GovKeeper.SubmitProposal(ctx, []sdk.Msg{msg}, "", "Bank Msg Send", "send message", addrs[0]) + proposal, err := suite.GovKeeper.SubmitProposal(ctx, []sdk.Msg{msg}, "", "title", "summary", proposer) require.NoError(t, err) proposalCoins := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, suite.StakingKeeper.TokensFromConsensusPower(ctx, 10))) diff --git a/x/gov/client/cli/tx.go b/x/gov/client/cli/tx.go index 9a94f765a3d..1ecf9655006 100644 --- a/x/gov/client/cli/tx.go +++ b/x/gov/client/cli/tx.go @@ -71,6 +71,7 @@ func NewTxCmd(legacyPropCmds []*cobra.Command) *cobra.Command { NewCmdWeightedVote(), NewCmdSubmitProposal(), NewCmdDraftProposal(), + NewCmdCancelProposal(), // Deprecated cmdSubmitLegacyProp, @@ -138,6 +139,36 @@ Where proposal.json contains: return cmd } +// NewCmdCancelProposal implements submitting a cancel proposal transaction command. +func NewCmdCancelProposal() *cobra.Command { + cmd := &cobra.Command{ + Use: "cancel-proposal [proposal-id]", + Short: "Cancel governance proposal before the voting period ends. Must be signed by the proposal creator.", + Args: cobra.ExactArgs(1), + Example: fmt.Sprintf(`$ %s tx gov cancel-proposal 1 --from mykey`, version.AppName), + RunE: func(cmd *cobra.Command, args []string) error { + clientCtx, err := client.GetClientTxContext(cmd) + if err != nil { + return err + } + + // validate that the proposal id is a uint + proposalID, err := strconv.ParseUint(args[0], 10, 64) + if err != nil { + return fmt.Errorf("proposal-id %s not a valid uint, please input a valid proposal-id", args[0]) + } + + // Get proposer address + from := clientCtx.GetFromAddress() + msg := v1.NewMsgCancelProposal(proposalID, from.String()) + return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg) + }, + } + + flags.AddTxFlagsToCmd(cmd) + return cmd +} + // NewCmdSubmitLegacyProposal implements submitting a proposal transaction command. // Deprecated: please use NewCmdSubmitProposal instead. func NewCmdSubmitLegacyProposal() *cobra.Command { diff --git a/x/gov/common_test.go b/x/gov/common_test.go index 6bca2818cb8..55e68443966 100644 --- a/x/gov/common_test.go +++ b/x/gov/common_test.go @@ -19,6 +19,8 @@ import ( _ "github.com/cosmos/cosmos-sdk/x/bank" bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper" _ "github.com/cosmos/cosmos-sdk/x/consensus" + _ "github.com/cosmos/cosmos-sdk/x/distribution" + distrkeeper "github.com/cosmos/cosmos-sdk/x/distribution/keeper" "github.com/cosmos/cosmos-sdk/x/gov/keeper" "github.com/cosmos/cosmos-sdk/x/gov/types" v1 "github.com/cosmos/cosmos-sdk/x/gov/types/v1" @@ -98,11 +100,12 @@ var pubkeys = []cryptotypes.PubKey{ } type suite struct { - AccountKeeper authkeeper.AccountKeeper - BankKeeper bankkeeper.Keeper - GovKeeper *keeper.Keeper - StakingKeeper *stakingkeeper.Keeper - App *runtime.App + AccountKeeper authkeeper.AccountKeeper + BankKeeper bankkeeper.Keeper + GovKeeper *keeper.Keeper + StakingKeeper *stakingkeeper.Keeper + DistributionKeeper distrkeeper.Keeper + App *runtime.App } func createTestSuite(t *testing.T) suite { @@ -116,9 +119,10 @@ func createTestSuite(t *testing.T) suite { configurator.BankModule(), configurator.GovModule(), configurator.ConsensusModule(), + configurator.DistributionModule(), ), simtestutil.DefaultStartUpConfig(), - &res.AccountKeeper, &res.BankKeeper, &res.GovKeeper, &res.StakingKeeper, + &res.AccountKeeper, &res.BankKeeper, &res.GovKeeper, &res.DistributionKeeper, &res.StakingKeeper, ) require.NoError(t, err) diff --git a/x/gov/keeper/common_test.go b/x/gov/keeper/common_test.go index 195355d69e8..e1b13622c4f 100644 --- a/x/gov/keeper/common_test.go +++ b/x/gov/keeper/common_test.go @@ -17,6 +17,7 @@ import ( moduletestutil "github.com/cosmos/cosmos-sdk/types/module/testutil" authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" banktypes "github.com/cosmos/cosmos-sdk/x/bank/types" + disttypes "github.com/cosmos/cosmos-sdk/x/distribution/types" "github.com/cosmos/cosmos-sdk/x/gov/keeper" govtestutil "github.com/cosmos/cosmos-sdk/x/gov/testutil" "github.com/cosmos/cosmos-sdk/x/gov/types" @@ -28,6 +29,7 @@ import ( var ( _, _, addr = testdata.KeyTestPubAddr() govAcct = authtypes.NewModuleAddress(types.ModuleName) + distAcct = authtypes.NewModuleAddress(disttypes.ModuleName) TestProposal = getTestProposal() ) @@ -50,6 +52,7 @@ func setupGovKeeper(t *testing.T) ( *govtestutil.MockAccountKeeper, *govtestutil.MockBankKeeper, *govtestutil.MockStakingKeeper, + *govtestutil.MockDistributionKeeper, moduletestutil.TestEncodingConfig, sdk.Context, ) { @@ -70,9 +73,12 @@ func setupGovKeeper(t *testing.T) ( acctKeeper := govtestutil.NewMockAccountKeeper(ctrl) bankKeeper := govtestutil.NewMockBankKeeper(ctrl) stakingKeeper := govtestutil.NewMockStakingKeeper(ctrl) + distributionKeeper := govtestutil.NewMockDistributionKeeper(ctrl) + acctKeeper.EXPECT().GetModuleAddress(types.ModuleName).Return(govAcct).AnyTimes() + acctKeeper.EXPECT().GetModuleAddress(disttypes.ModuleName).Return(distAcct).AnyTimes() acctKeeper.EXPECT().GetModuleAccount(gomock.Any(), types.ModuleName).Return(authtypes.NewEmptyModuleAccount(types.ModuleName)).AnyTimes() - trackMockBalances(bankKeeper) + trackMockBalances(bankKeeper, distributionKeeper) stakingKeeper.EXPECT().TokensFromConsensusPower(ctx, gomock.Any()).DoAndReturn(func(ctx sdk.Context, power int64) math.Int { return sdk.TokensFromConsensusPower(power, math.NewIntFromUint64(1000000)) }).AnyTimes() @@ -80,9 +86,10 @@ func setupGovKeeper(t *testing.T) ( stakingKeeper.EXPECT().IterateBondedValidatorsByPower(gomock.Any(), gomock.Any()).AnyTimes() stakingKeeper.EXPECT().IterateDelegations(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() stakingKeeper.EXPECT().TotalBondedTokens(gomock.Any()).Return(math.NewInt(10000000)).AnyTimes() + distributionKeeper.EXPECT().FundCommunityPool(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes() // Gov keeper initializations - govKeeper := keeper.NewKeeper(encCfg.Codec, key, acctKeeper, bankKeeper, stakingKeeper, msr, types.DefaultConfig(), govAcct.String()) + govKeeper := keeper.NewKeeper(encCfg.Codec, key, acctKeeper, bankKeeper, stakingKeeper, distributionKeeper, msr, types.DefaultConfig(), govAcct.String()) govKeeper.SetProposalID(ctx, 1) govRouter := v1beta1.NewRouter() // Also register legacy gov handlers to test them too. govRouter.AddRoute(types.RouterKey, v1beta1.ProposalHandler) @@ -94,13 +101,14 @@ func setupGovKeeper(t *testing.T) ( v1.RegisterMsgServer(msr, keeper.NewMsgServerImpl(govKeeper)) banktypes.RegisterMsgServer(msr, nil) // Nil is fine here as long as we never execute the proposal's Msgs. - return govKeeper, acctKeeper, bankKeeper, stakingKeeper, encCfg, ctx + return govKeeper, acctKeeper, bankKeeper, stakingKeeper, distributionKeeper, encCfg, ctx } // trackMockBalances sets up expected calls on the Mock BankKeeper, and also // locally tracks accounts balances (not modules balances). -func trackMockBalances(bankKeeper *govtestutil.MockBankKeeper) { +func trackMockBalances(bankKeeper *govtestutil.MockBankKeeper, distributionKeeper *govtestutil.MockDistributionKeeper) { balances := make(map[string]sdk.Coins) + balances[distAcct.String()] = sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(0))) // We don't track module account balances. bankKeeper.EXPECT().MintCoins(gomock.Any(), minttypes.ModuleName, gomock.Any()).AnyTimes() @@ -123,4 +131,25 @@ func trackMockBalances(bankKeeper *govtestutil.MockBankKeeper) { bankKeeper.EXPECT().GetAllBalances(gomock.Any(), gomock.Any()).DoAndReturn(func(_ sdk.Context, addr sdk.AccAddress) sdk.Coins { return balances[addr.String()] }).AnyTimes() + bankKeeper.EXPECT().GetBalance(gomock.Any(), gomock.Any(), sdk.DefaultBondDenom).DoAndReturn(func(_ sdk.Context, addr sdk.AccAddress, _ string) sdk.Coin { + balances := balances[addr.String()] + for _, balance := range balances { + if balance.Denom == sdk.DefaultBondDenom { + return balance + } + } + return sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(0)) + }).AnyTimes() + + distributionKeeper.EXPECT().FundCommunityPool(gomock.Any(), gomock.Any(), gomock.Any()).DoAndReturn(func(_ sdk.Context, coins sdk.Coins, sender sdk.AccAddress) error { + // sender balance + newBalance, negative := balances[sender.String()].SafeSub(coins...) + if negative { + return fmt.Errorf("not enough balance") + } + balances[sender.String()] = newBalance + // receiver balance + balances[distAcct.String()] = balances[distAcct.String()].Add(coins...) + return nil + }).AnyTimes() } diff --git a/x/gov/keeper/deposit.go b/x/gov/keeper/deposit.go index 8beb64a5ef9..cd9f10a6391 100644 --- a/x/gov/keeper/deposit.go +++ b/x/gov/keeper/deposit.go @@ -6,6 +6,7 @@ import ( storetypes "github.com/cosmos/cosmos-sdk/store/types" sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + disttypes "github.com/cosmos/cosmos-sdk/x/distribution/types" "github.com/cosmos/cosmos-sdk/x/gov/types" v1 "github.com/cosmos/cosmos-sdk/x/gov/types/v1" ) @@ -163,6 +164,77 @@ func (keeper Keeper) AddDeposit(ctx sdk.Context, proposalID uint64, depositorAdd return activatedVotingPeriod, nil } +// ChargeDeposit will charge proposal cancellation fee (deposits * proposal_cancel_burn_rate) and +// send to a destAddress if defined or burn otherwise. +// Remaining funds are send back to the depositor. +func (keeper Keeper) ChargeDeposit(ctx sdk.Context, proposalID uint64, destAddress, proposalCancelRate string) error { + store := ctx.KVStore(keeper.storeKey) + rate := sdk.MustNewDecFromStr(proposalCancelRate) + var cancellationCharges sdk.Coins + + for _, deposits := range keeper.GetDeposits(ctx, proposalID) { + depositerAddress := sdk.MustAccAddressFromBech32(deposits.Depositor) + var remainingAmount sdk.Coins + + for _, deposit := range deposits.Amount { + burnAmount := sdk.NewDecFromInt(deposit.Amount).Mul(rate).TruncateInt() + // remaining amount = deposits amount - burn amount + remainingAmount = remainingAmount.Add( + sdk.NewCoin( + deposit.Denom, + deposit.Amount.Sub(burnAmount), + ), + ) + cancellationCharges = cancellationCharges.Add( + sdk.NewCoin( + deposit.Denom, + burnAmount, + ), + ) + } + + if !remainingAmount.IsZero() { + err := keeper.bankKeeper.SendCoinsFromModuleToAccount( + ctx, types.ModuleName, depositerAddress, remainingAmount, + ) + if err != nil { + return err + } + } + } + + // burn the cancellation fee or sent the cancellation charges to destination address. + if !cancellationCharges.IsZero() { + // get the distribution module account address + distributionAddress := keeper.authKeeper.GetModuleAddress(disttypes.ModuleName) + switch { + case len(destAddress) == 0: + // burn the cancellation charges from deposits + err := keeper.bankKeeper.BurnCoins(ctx, types.ModuleName, cancellationCharges) + if err != nil { + return err + } + case distributionAddress.String() == destAddress: + err := keeper.distrkeeper.FundCommunityPool(ctx, cancellationCharges, keeper.ModuleAccountAddress()) + if err != nil { + return err + } + default: + destAccAddress := sdk.MustAccAddressFromBech32(destAddress) + err := keeper.bankKeeper.SendCoinsFromModuleToAccount( + ctx, types.ModuleName, destAccAddress, cancellationCharges, + ) + if err != nil { + return err + } + } + } + + store.Delete(types.DepositsKey(proposalID)) + + return nil +} + // RefundAndDeleteDeposits refunds and deletes all the deposits on a specific proposal. func (keeper Keeper) RefundAndDeleteDeposits(ctx sdk.Context, proposalID uint64) { store := ctx.KVStore(keeper.storeKey) diff --git a/x/gov/keeper/deposit_test.go b/x/gov/keeper/deposit_test.go index edac1a62b89..747ed74f78a 100644 --- a/x/gov/keeper/deposit_test.go +++ b/x/gov/keeper/deposit_test.go @@ -1,12 +1,16 @@ package keeper_test import ( + "fmt" "testing" + "cosmossdk.io/math" "github.com/stretchr/testify/require" simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims" sdk "github.com/cosmos/cosmos-sdk/types" + authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" + disttypes "github.com/cosmos/cosmos-sdk/x/distribution/types" v1 "github.com/cosmos/cosmos-sdk/x/gov/types/v1" ) @@ -16,12 +20,12 @@ const ( ) func TestDeposits(t *testing.T) { - govKeeper, _, bankKeeper, stakingKeeper, _, ctx := setupGovKeeper(t) - trackMockBalances(bankKeeper) + govKeeper, _, bankKeeper, stakingKeeper, distKeeper, _, ctx := setupGovKeeper(t) + trackMockBalances(bankKeeper, distKeeper) TestAddrs := simtestutil.AddTestAddrsIncremental(bankKeeper, stakingKeeper, ctx, 2, sdk.NewInt(10000000)) tp := TestProposal - proposal, err := govKeeper.SubmitProposal(ctx, tp, "", "title", "description", TestAddrs[0]) + proposal, err := govKeeper.SubmitProposal(ctx, tp, "", "title", "summary", TestAddrs[0]) require.NoError(t, err) proposalID := proposal.Id @@ -105,7 +109,7 @@ func TestDeposits(t *testing.T) { require.Equal(t, addr1Initial, bankKeeper.GetAllBalances(ctx, TestAddrs[1])) // Test delete and burn deposits - proposal, err = govKeeper.SubmitProposal(ctx, tp, "", "title", "description", TestAddrs[0]) + proposal, err = govKeeper.SubmitProposal(ctx, tp, "", "title", "summary", TestAddrs[0]) require.NoError(t, err) proposalID = proposal.Id _, err = govKeeper.AddDeposit(ctx, proposalID, TestAddrs[0], fourStake) @@ -193,7 +197,7 @@ func TestValidateInitialDeposit(t *testing.T) { for name, tc := range testcases { t.Run(name, func(t *testing.T) { - govKeeper, _, _, _, _, ctx := setupGovKeeper(t) + govKeeper, _, _, _, _, _, ctx := setupGovKeeper(t) params := v1.DefaultParams() params.MinDeposit = tc.minDeposit @@ -211,3 +215,106 @@ func TestValidateInitialDeposit(t *testing.T) { }) } } + +func TestChargeDeposit(t *testing.T) { + testCases := []struct { + name string + proposalCancelRatio string + proposalCancelDestAddress string + expectError bool + }{ + { + name: "Success: CancelRatio=0", + proposalCancelRatio: "0", + proposalCancelDestAddress: "", + expectError: false, + }, + { + name: "Success: CancelRatio=0.5", + proposalCancelRatio: "0.5", + proposalCancelDestAddress: "", + expectError: false, + }, + { + name: "Success: CancelRatio=1", + proposalCancelRatio: "1", + proposalCancelDestAddress: "", + expectError: false, + }, + } + + for _, tc := range testCases { + for i := 0; i < 3; i++ { + testName := func(i int) string { + if i == 0 { + return fmt.Sprintf("%s and dest address is %s", tc.name, "nil") + } else if i == 1 { + return fmt.Sprintf("%s and dest address is normal address", tc.name) + } + return fmt.Sprintf("%s and dest address is community address", tc.name) + } + + t.Run(testName(i), func(t *testing.T) { + govKeeper, _, bankKeeper, stakingKeeper, _, _, ctx := setupGovKeeper(t) + params := v1.DefaultParams() + params.ProposalCancelRatio = tc.proposalCancelRatio + TestAddrs := simtestutil.AddTestAddrsIncremental(bankKeeper, stakingKeeper, ctx, 2, sdk.NewInt(10000000000)) + + switch i { + case 0: + // no dest address for cancel proposal, total cancellation charges will be burned + params.ProposalCancelDest = "" + case 1: + // normal account address for proposal cancel dest address + params.ProposalCancelDest = TestAddrs[1].String() + default: + // community address for proposal cancel dest address + params.ProposalCancelDest = authtypes.NewModuleAddress(disttypes.ModuleName).String() + } + + err := govKeeper.SetParams(ctx, params) + require.NoError(t, err) + + tp := TestProposal + proposal, err := govKeeper.SubmitProposal(ctx, tp, "", "title", "summary", TestAddrs[0]) + require.NoError(t, err) + proposalID := proposal.Id + // deposit to proposal + fiveStake := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, stakingKeeper.TokensFromConsensusPower(ctx, 300))) + _, err = govKeeper.AddDeposit(ctx, proposalID, TestAddrs[0], fiveStake) + require.NoError(t, err) + + // get balances of dest address + var prevBalance sdk.Coin + if len(params.ProposalCancelDest) != 0 { + accAddr := sdk.MustAccAddressFromBech32(params.ProposalCancelDest) + prevBalance = bankKeeper.GetBalance(ctx, accAddr, sdk.DefaultBondDenom) + } + + // get the deposits + allDeposits := govKeeper.GetDeposits(ctx, proposalID) + + // charge cancellation charges for cancel proposal + err = govKeeper.ChargeDeposit(ctx, proposalID, TestAddrs[0].String(), params.ProposalCancelRatio) + if tc.expectError { + require.Error(t, err) + return + } + require.NoError(t, err) + + if len(params.ProposalCancelDest) != 0 { + accAddr := sdk.MustAccAddressFromBech32(params.ProposalCancelDest) + newBalanceAfterCancelProposal := bankKeeper.GetBalance(ctx, accAddr, sdk.DefaultBondDenom) + cancellationCharges := math.NewInt(0) + for _, deposits := range allDeposits { + for _, deposit := range deposits.Amount { + burnAmount := sdk.NewDecFromInt(deposit.Amount).Mul(sdk.MustNewDecFromStr(params.MinInitialDepositRatio)).TruncateInt() + cancellationCharges = cancellationCharges.Add(burnAmount) + } + } + require.True(t, newBalanceAfterCancelProposal.Equal(prevBalance.Add(sdk.NewCoin(sdk.DefaultBondDenom, cancellationCharges)))) + } + }) + } + } +} diff --git a/x/gov/keeper/grpc_query_test.go b/x/gov/keeper/grpc_query_test.go index 96dd1921cd1..8cbb4802fd7 100644 --- a/x/gov/keeper/grpc_query_test.go +++ b/x/gov/keeper/grpc_query_test.go @@ -17,7 +17,7 @@ import ( func (suite *KeeperTestSuite) TestGRPCQueryProposal() { suite.reset() - ctx, queryClient := suite.ctx, suite.queryClient + ctx, queryClient, addrs := suite.ctx, suite.queryClient, suite.addrs var ( req *v1.QueryProposalRequest @@ -57,7 +57,7 @@ func (suite *KeeperTestSuite) TestGRPCQueryProposal() { testProposal := v1beta1.NewTextProposal("Proposal", "testing proposal") msgContent, err := v1.NewLegacyContent(testProposal, govAcct.String()) suite.Require().NoError(err) - submittedProposal, err := suite.govKeeper.SubmitProposal(ctx, []sdk.Msg{msgContent}, "", "test", "summary", sdk.AccAddress("cosmos1ghekyjucln7y67ntx7cf27m9dpuxxemn4c8g4r")) + submittedProposal, err := suite.govKeeper.SubmitProposal(ctx, []sdk.Msg{msgContent}, "", "title", "summary", addrs[0]) suite.Require().NoError(err) suite.Require().NotEmpty(submittedProposal) @@ -87,7 +87,7 @@ func (suite *KeeperTestSuite) TestGRPCQueryProposal() { func (suite *KeeperTestSuite) TestLegacyGRPCQueryProposal() { suite.reset() - ctx, queryClient := suite.ctx, suite.legacyQueryClient + ctx, queryClient, addrs := suite.ctx, suite.legacyQueryClient, suite.addrs var ( req *v1beta1.QueryProposalRequest @@ -127,7 +127,7 @@ func (suite *KeeperTestSuite) TestLegacyGRPCQueryProposal() { testProposal := v1beta1.NewTextProposal("Proposal", "testing proposal") msgContent, err := v1.NewLegacyContent(testProposal, govAcct.String()) suite.Require().NoError(err) - submittedProposal, err := suite.govKeeper.SubmitProposal(ctx, []sdk.Msg{msgContent}, "", "test", "summary", sdk.AccAddress("cosmos1ghekyjucln7y67ntx7cf27m9dpuxxemn4c8g4r")) + submittedProposal, err := suite.govKeeper.SubmitProposal(ctx, []sdk.Msg{msgContent}, "", "title", "summary", addrs[0]) suite.Require().NoError(err) suite.Require().NotEmpty(submittedProposal) @@ -188,7 +188,7 @@ func (suite *KeeperTestSuite) TestGRPCQueryProposals() { testProposal := []sdk.Msg{ v1.NewMsgVote(govAddress, uint64(i), v1.OptionYes, ""), } - proposal, err := suite.govKeeper.SubmitProposal(ctx, testProposal, "", "test", "summary", sdk.AccAddress("cosmos1ghekyjucln7y67ntx7cf27m9dpuxxemn4c8g4r")) + proposal, err := suite.govKeeper.SubmitProposal(ctx, testProposal, "", "title", "summary", addrs[0]) suite.Require().NotEmpty(proposal) suite.Require().NoError(err) testProposals = append(testProposals, &proposal) @@ -305,7 +305,7 @@ func (suite *KeeperTestSuite) TestGRPCQueryProposals() { func (suite *KeeperTestSuite) TestLegacyGRPCQueryProposals() { suite.reset() - ctx, queryClient := suite.ctx, suite.legacyQueryClient + ctx, queryClient, addrs := suite.ctx, suite.legacyQueryClient, suite.addrs var req *v1beta1.QueryProposalsRequest @@ -321,7 +321,7 @@ func (suite *KeeperTestSuite) TestLegacyGRPCQueryProposals() { testProposal := v1beta1.NewTextProposal("Proposal", "testing proposal") msgContent, err := v1.NewLegacyContent(testProposal, govAcct.String()) suite.Require().NoError(err) - submittedProposal, err := suite.govKeeper.SubmitProposal(ctx, []sdk.Msg{msgContent}, "", "test", "summary", sdk.AccAddress("cosmos1ghekyjucln7y67ntx7cf27m9dpuxxemn4c8g4r")) + submittedProposal, err := suite.govKeeper.SubmitProposal(ctx, []sdk.Msg{msgContent}, "", "title", "summary", addrs[0]) suite.Require().NoError(err) suite.Require().NotEmpty(submittedProposal) }, @@ -402,7 +402,7 @@ func (suite *KeeperTestSuite) TestGRPCQueryVote() { "no votes present", func() { var err error - proposal, err = suite.govKeeper.SubmitProposal(ctx, TestProposal, "", "test", "summary", addrs[0]) + proposal, err = suite.govKeeper.SubmitProposal(ctx, TestProposal, "", "title", "summary", addrs[0]) suite.Require().NoError(err) req = &v1.QueryVoteRequest{ @@ -516,7 +516,7 @@ func (suite *KeeperTestSuite) TestLegacyGRPCQueryVote() { "no votes present", func() { var err error - proposal, err = suite.govKeeper.SubmitProposal(ctx, TestProposal, "", "test", "summary", addrs[0]) + proposal, err = suite.govKeeper.SubmitProposal(ctx, TestProposal, "", "title", "summary", addrs[0]) suite.Require().NoError(err) req = &v1beta1.QueryVoteRequest{ @@ -622,7 +622,7 @@ func (suite *KeeperTestSuite) TestGRPCQueryVotes() { "create a proposal and get votes", func() { var err error - proposal, err = suite.govKeeper.SubmitProposal(ctx, TestProposal, "", "test", "summary", addrs[0]) + proposal, err = suite.govKeeper.SubmitProposal(ctx, TestProposal, "", "title", "summary", addrs[0]) suite.Require().NoError(err) req = &v1.QueryVotesRequest{ @@ -724,7 +724,7 @@ func (suite *KeeperTestSuite) TestLegacyGRPCQueryVotes() { "create a proposal and get votes", func() { var err error - proposal, err = suite.govKeeper.SubmitProposal(ctx, TestProposal, "", "test", "summary", addrs[0]) + proposal, err = suite.govKeeper.SubmitProposal(ctx, TestProposal, "", "title", "summary", addrs[0]) suite.Require().NoError(err) req = &v1beta1.QueryVotesRequest{ @@ -1009,7 +1009,7 @@ func (suite *KeeperTestSuite) TestGRPCQueryDeposit() { "no deposits proposal", func() { var err error - proposal, err = suite.govKeeper.SubmitProposal(ctx, TestProposal, "", "test", "summary", addrs[0]) + proposal, err = suite.govKeeper.SubmitProposal(ctx, TestProposal, "", "title", "summary", addrs[0]) suite.Require().NoError(err) suite.Require().NotNil(proposal) @@ -1110,7 +1110,7 @@ func (suite *KeeperTestSuite) TestLegacyGRPCQueryDeposit() { "no deposits proposal", func() { var err error - proposal, err = suite.govKeeper.SubmitProposal(ctx, TestProposal, "", "test", "summary", addrs[0]) + proposal, err = suite.govKeeper.SubmitProposal(ctx, TestProposal, "", "title", "summary", addrs[0]) suite.Require().NoError(err) suite.Require().NotNil(proposal) @@ -1200,7 +1200,7 @@ func (suite *KeeperTestSuite) TestGRPCQueryDeposits() { "create a proposal and get deposits", func() { var err error - proposal, err = suite.govKeeper.SubmitProposal(ctx, TestProposal, "", "test", "summary", addrs[0]) + proposal, err = suite.govKeeper.SubmitProposal(ctx, TestProposal, "", "title", "summary", addrs[0]) suite.Require().NoError(err) req = &v1.QueryDepositsRequest{ @@ -1295,7 +1295,7 @@ func (suite *KeeperTestSuite) TestLegacyGRPCQueryDeposits() { "create a proposal and get deposits", func() { var err error - proposal, err = suite.govKeeper.SubmitProposal(ctx, TestProposal, "", "test", "summary", addrs[0]) + proposal, err = suite.govKeeper.SubmitProposal(ctx, TestProposal, "", "title", "summary", addrs[0]) suite.Require().NoError(err) req = &v1beta1.QueryDepositsRequest{ diff --git a/x/gov/keeper/hooks_test.go b/x/gov/keeper/hooks_test.go index cf07cd12132..14c0c050022 100644 --- a/x/gov/keeper/hooks_test.go +++ b/x/gov/keeper/hooks_test.go @@ -47,7 +47,7 @@ func (h *MockGovHooksReceiver) AfterProposalVotingPeriodEnded(ctx sdk.Context, p func TestHooks(t *testing.T) { minDeposit := v1.DefaultParams().MinDeposit - govKeeper, _, bankKeeper, stakingKeeper, _, ctx := setupGovKeeper(t) + govKeeper, _, bankKeeper, stakingKeeper, _, _, ctx := setupGovKeeper(t) addrs := simtestutil.AddTestAddrs(bankKeeper, stakingKeeper, ctx, 1, minDeposit[0].Amount) govHooksReceiver := MockGovHooksReceiver{} diff --git a/x/gov/keeper/keeper.go b/x/gov/keeper/keeper.go index 2af72d8ec7c..985b15e34bb 100644 --- a/x/gov/keeper/keeper.go +++ b/x/gov/keeper/keeper.go @@ -17,8 +17,9 @@ import ( // Keeper defines the governance module Keeper type Keeper struct { - authKeeper types.AccountKeeper - bankKeeper types.BankKeeper + authKeeper types.AccountKeeper + bankKeeper types.BankKeeper + distrkeeper types.DistributionKeeper // The reference to the DelegationSet and ValidatorSet to get information about validators and delegators sk types.StakingKeeper @@ -59,7 +60,7 @@ func (k Keeper) GetAuthority() string { // CONTRACT: the parameter Subspace must have the param key table already initialized func NewKeeper( cdc codec.BinaryCodec, key storetypes.StoreKey, authKeeper types.AccountKeeper, - bankKeeper types.BankKeeper, sk types.StakingKeeper, + bankKeeper types.BankKeeper, sk types.StakingKeeper, distrkeeper types.DistributionKeeper, router *baseapp.MsgServiceRouter, config types.Config, authority string, ) *Keeper { // ensure governance module account is set @@ -77,14 +78,15 @@ func NewKeeper( } return &Keeper{ - storeKey: key, - authKeeper: authKeeper, - bankKeeper: bankKeeper, - sk: sk, - cdc: cdc, - router: router, - config: config, - authority: authority, + storeKey: key, + authKeeper: authKeeper, + bankKeeper: bankKeeper, + distrkeeper: distrkeeper, + sk: sk, + cdc: cdc, + router: router, + config: config, + authority: authority, } } @@ -218,6 +220,11 @@ func (k Keeper) InactiveProposalQueueIterator(ctx sdk.Context, endTime time.Time return store.Iterator(types.InactiveProposalQueuePrefix, storetypes.PrefixEndBytes(types.InactiveProposalByTimeKey(endTime))) } +// ModuleAccountAddress returns gov module account address +func (k Keeper) ModuleAccountAddress() sdk.AccAddress { + return k.authKeeper.GetModuleAddress(types.ModuleName) +} + // assertMetadataLength returns an error if given metadata length // is greater than a pre-defined MaxMetadataLen. func (k Keeper) assertMetadataLength(metadata string) error { diff --git a/x/gov/keeper/keeper_test.go b/x/gov/keeper/keeper_test.go index 03004ade804..d9c6a7bb474 100644 --- a/x/gov/keeper/keeper_test.go +++ b/x/gov/keeper/keeper_test.go @@ -27,6 +27,7 @@ type KeeperTestSuite struct { acctKeeper *govtestutil.MockAccountKeeper bankKeeper *govtestutil.MockBankKeeper stakingKeeper *govtestutil.MockStakingKeeper + distKeeper *govtestutil.MockDistributionKeeper queryClient v1.QueryClient legacyQueryClient v1beta1.QueryClient addrs []sdk.AccAddress @@ -39,7 +40,7 @@ func (suite *KeeperTestSuite) SetupSuite() { } func (suite *KeeperTestSuite) reset() { - govKeeper, acctKeeper, bankKeeper, stakingKeeper, encCfg, ctx := setupGovKeeper(suite.T()) + govKeeper, acctKeeper, bankKeeper, stakingKeeper, distKeeper, encCfg, ctx := setupGovKeeper(suite.T()) // Populate the gov account with some coins, as the TestProposal we have // is a MsgSend from the gov account. @@ -61,6 +62,7 @@ func (suite *KeeperTestSuite) reset() { suite.acctKeeper = acctKeeper suite.bankKeeper = bankKeeper suite.stakingKeeper = stakingKeeper + suite.distKeeper = distKeeper suite.cdc = encCfg.Codec suite.queryClient = queryClient suite.legacyQueryClient = legacyQueryClient @@ -71,7 +73,7 @@ func (suite *KeeperTestSuite) reset() { } func TestIncrementProposalNumber(t *testing.T) { - govKeeper, _, _, _, _, ctx := setupGovKeeper(t) //nolint:dogsled + govKeeper, _, _, _, _, _, ctx := setupGovKeeper(t) //nolint:dogsled tp := TestProposal _, err := govKeeper.SubmitProposal(ctx, tp, "", "test", "summary", sdk.AccAddress("cosmos1ghekyjucln7y67ntx7cf27m9dpuxxemn4c8g4r")) @@ -91,7 +93,7 @@ func TestIncrementProposalNumber(t *testing.T) { } func TestProposalQueues(t *testing.T) { - govKeeper, _, _, _, _, ctx := setupGovKeeper(t) //nolint:dogsled + govKeeper, _, _, _, _, _, ctx := setupGovKeeper(t) //nolint:dogsled // create test proposals tp := TestProposal diff --git a/x/gov/keeper/msg_server.go b/x/gov/keeper/msg_server.go index c66d011552c..0f699d86581 100644 --- a/x/gov/keeper/msg_server.go +++ b/x/gov/keeper/msg_server.go @@ -37,12 +37,12 @@ func (k msgServer) SubmitProposal(goCtx context.Context, msg *v1.MsgSubmitPropos return nil, err } - proposalMsgs, err := msg.GetMsgs() + proposer, err := sdk.AccAddressFromBech32(msg.GetProposer()) if err != nil { return nil, err } - proposer, err := sdk.AccAddressFromBech32(msg.GetProposer()) + proposalMsgs, err := msg.GetMsgs() if err != nil { return nil, err } @@ -83,6 +83,33 @@ func (k msgServer) SubmitProposal(goCtx context.Context, msg *v1.MsgSubmitPropos }, nil } +// CancelProposals implements the MsgServer.CancelProposal method. +func (k msgServer) CancelProposal(goCtx context.Context, msg *v1.MsgCancelProposal) (*v1.MsgCancelProposalResponse, error) { + ctx := sdk.UnwrapSDKContext(goCtx) + _, err := sdk.AccAddressFromBech32(msg.Proposer) + if err != nil { + return nil, err + } + + if err := k.Keeper.CancelProposal(ctx, msg.ProposalId, msg.Proposer); err != nil { + return nil, err + } + + ctx.EventManager().EmitEvent( + sdk.NewEvent( + govtypes.EventTypeCancelProposal, + sdk.NewAttribute(sdk.AttributeKeySender, msg.Proposer), + sdk.NewAttribute(govtypes.AttributeKeyProposalID, fmt.Sprint(msg.ProposalId)), + ), + ) + + return &v1.MsgCancelProposalResponse{ + ProposalId: msg.ProposalId, + CanceledTime: ctx.BlockTime(), + CanceledHeight: uint64(ctx.BlockHeight()), + }, nil +} + // ExecLegacyContent implements the MsgServer.ExecLegacyContent method. func (k msgServer) ExecLegacyContent(goCtx context.Context, msg *v1.MsgExecLegacyContent) (*v1.MsgExecLegacyContentResponse, error) { ctx := sdk.UnwrapSDKContext(goCtx) diff --git a/x/gov/keeper/msg_server_test.go b/x/gov/keeper/msg_server_test.go index ebef08cf2da..bd1f98612fa 100644 --- a/x/gov/keeper/msg_server_test.go +++ b/x/gov/keeper/msg_server_test.go @@ -132,6 +132,74 @@ func (suite *KeeperTestSuite) TestSubmitProposalReq() { } } +func (suite *KeeperTestSuite) TestCancelProposalReq() { + govAcct := suite.govKeeper.GetGovernanceAccount(suite.ctx).GetAddress() + addrs := suite.addrs + proposer := addrs[0] + + coins := sdk.NewCoins(sdk.NewCoin("stake", sdk.NewInt(100))) + bankMsg := &banktypes.MsgSend{ + FromAddress: govAcct.String(), + ToAddress: proposer.String(), + Amount: coins, + } + + msg, err := v1.NewMsgSubmitProposal( + []sdk.Msg{bankMsg}, + coins, + proposer.String(), "", + "title", "summary", + ) + suite.Require().NoError(err) + + res, err := suite.msgSrvr.SubmitProposal(suite.ctx, msg) + suite.Require().NoError(err) + suite.Require().NotNil(res.ProposalId) + proposalID := res.ProposalId + + cases := map[string]struct { + preRun func() uint64 + expErr bool + proposalID uint64 + depositor sdk.AccAddress + }{ + "wrong proposal id": { + preRun: func() uint64 { + return 0 + }, + depositor: proposer, + expErr: true, + }, + "valid proposal but invalid proposer": { + preRun: func() uint64 { + return proposalID + }, + depositor: addrs[1], + expErr: true, + }, + "all good": { + preRun: func() uint64 { + return proposalID + }, + depositor: proposer, + expErr: false, + }, + } + + for name, tc := range cases { + suite.Run(name, func() { + proposalID := tc.preRun() + cancelProposalReq := v1.NewMsgCancelProposal(proposalID, tc.depositor.String()) + _, err := suite.msgSrvr.CancelProposal(suite.ctx, cancelProposalReq) + if tc.expErr { + suite.Require().Error(err) + } else { + suite.Require().NoError(err) + } + }) + } +} + func (suite *KeeperTestSuite) TestVoteReq() { suite.reset() govAcct := suite.govKeeper.GetGovernanceAccount(suite.ctx).GetAddress() diff --git a/x/gov/keeper/proposal.go b/x/gov/keeper/proposal.go index 8c72b315a0b..8dd7eb8dd8b 100644 --- a/x/gov/keeper/proposal.go +++ b/x/gov/keeper/proposal.go @@ -108,6 +108,57 @@ func (keeper Keeper) SubmitProposal(ctx sdk.Context, messages []sdk.Msg, metadat return proposal, nil } +// CancelProposal will cancel proposal before the voting period ends +func (keeper Keeper) CancelProposal(ctx sdk.Context, proposalID uint64, proposer string) error { + proposal, ok := keeper.GetProposal(ctx, proposalID) + if !ok { + return sdkerrors.Wrapf(types.ErrProposalNotFound, "proposal_id %d", proposalID) + } + + // Checking proposal have proposer or not because old proposal doesn't have proposer field, + // https://github.com/cosmos/cosmos-sdk/blob/v0.46.2/proto/cosmos/gov/v1/gov.proto#L43 + if proposal.Proposer == "" { + return types.ErrInvalidProposal.Wrapf("proposal %d doesn't have proposer %s, so cannot be canceled", proposalID, proposer) + } + + // Check creator of the proposal + if proposal.Proposer != proposer { + return types.ErrInvalidProposer.Wrapf("invalid proposer %s", proposer) + } + + // Check if proposal is active or not + if (proposal.Status != v1.StatusDepositPeriod) && (proposal.Status != v1.StatusVotingPeriod) { + return types.ErrInvalidProposal.Wrap("proposal should be in the deposit or voting period") + } + + // Check proposal voting period is ended. + if proposal.VotingEndTime != nil && proposal.VotingEndTime.Before(ctx.BlockTime()) { + return types.ErrVotingPeriodEnded.Wrapf("voting period is already ended for this proposal %d", proposalID) + } + + // burn the (deposits * proposal_cancel_rate) amount or sent to cancellation destination address. + // and deposits * (1 - proposal_cancel_rate) will be sent to depositors. + params := keeper.GetParams(ctx) + err := keeper.ChargeDeposit(ctx, proposal.Id, params.ProposalCancelDest, params.ProposalCancelRatio) + if err != nil { + return err + } + + if proposal.VotingStartTime != nil { + keeper.deleteVotes(ctx, proposal.Id) + } + + keeper.DeleteProposal(ctx, proposal.Id) + + keeper.Logger(ctx).Info( + "proposal is canceled by proposer", + "proposal", proposal.Id, + "proposer", proposal.Proposer, + ) + + return nil +} + // GetProposal gets a proposal from store by ProposalID. // Panics if can't unmarshal the proposal. func (keeper Keeper) GetProposal(ctx sdk.Context, proposalID uint64) (v1.Proposal, bool) { diff --git a/x/gov/keeper/proposal_test.go b/x/gov/keeper/proposal_test.go index d135c954bc2..b070df4e499 100644 --- a/x/gov/keeper/proposal_test.go +++ b/x/gov/keeper/proposal_test.go @@ -160,6 +160,79 @@ func (suite *KeeperTestSuite) TestGetProposalsFiltered() { } } +func (suite *KeeperTestSuite) TestCancelProposal() { + govAcct := suite.govKeeper.GetGovernanceAccount(suite.ctx).GetAddress().String() + tp := v1beta1.TextProposal{Title: "title", Description: "description"} + prop, err := v1.NewLegacyContent(&tp, govAcct) + suite.Require().NoError(err) + proposalResp, err := suite.govKeeper.SubmitProposal(suite.ctx, []sdk.Msg{prop}, "", "title", "summary", suite.addrs[0]) + suite.Require().NoError(err) + proposalID := proposalResp.Id + + proposal2Resp, err := suite.govKeeper.SubmitProposal(suite.ctx, []sdk.Msg{prop}, "", "title", "summary", suite.addrs[1]) + proposal2ID := proposal2Resp.Id + makeProposalPass := func() { + proposal2, ok := suite.govKeeper.GetProposal(suite.ctx, proposal2ID) + suite.Require().True(ok) + + proposal2.Status = v1.ProposalStatus_PROPOSAL_STATUS_PASSED + suite.govKeeper.SetProposal(suite.ctx, proposal2) + } + + testCases := []struct { + name string + proposalID uint64 + proposer string + expectedErr bool + }{ + { + name: "without proposer", + proposalID: 1, + proposer: "", + expectedErr: true, + }, + { + name: "invalid proposal id", + proposalID: 1, + proposer: string(suite.addrs[0]), + expectedErr: true, + }, + { + name: "valid proposalID but invalid proposer", + proposalID: proposalID, + proposer: suite.addrs[1].String(), + expectedErr: true, + }, + { + name: "valid proposalID but invalid proposal which has already passed", + proposalID: proposal2ID, + proposer: suite.addrs[1].String(), + expectedErr: true, + }, + { + name: "valid proposer and proposal id", + proposalID: proposalID, + proposer: suite.addrs[0].String(), + expectedErr: false, + }, + } + + for _, tc := range testCases { + suite.Run(tc.name, func() { + if tc.proposalID == proposal2ID { + // making proposal status pass + makeProposalPass() + } + err = suite.govKeeper.CancelProposal(suite.ctx, tc.proposalID, tc.proposer) + if tc.expectedErr { + suite.Require().Error(err) + } else { + suite.Require().NoError(err) + } + }) + } +} + func TestMigrateProposalMessages(t *testing.T) { content := v1beta1.NewTextProposal("Test", "description") contentMsg, err := v1.NewLegacyContent(content, sdk.AccAddress("test1").String()) diff --git a/x/gov/keeper/vote.go b/x/gov/keeper/vote.go index c98e9024be4..7a45f7e1843 100644 --- a/x/gov/keeper/vote.go +++ b/x/gov/keeper/vote.go @@ -118,6 +118,12 @@ func (keeper Keeper) IterateVotes(ctx sdk.Context, proposalID uint64, cb func(vo } } +// deleteVotes deletes the all votes from a given proposalID. +func (keeper Keeper) deleteVotes(ctx sdk.Context, proposalID uint64) { + store := ctx.KVStore(keeper.storeKey) + store.Delete(types.VotesKey(proposalID)) +} + // deleteVote deletes a vote from a given proposalID and voter from the store func (keeper Keeper) deleteVote(ctx sdk.Context, proposalID uint64, voterAddr sdk.AccAddress) { store := ctx.KVStore(keeper.storeKey) diff --git a/x/gov/keeper/vote_test.go b/x/gov/keeper/vote_test.go index 048b75c38d0..fbad33c255e 100644 --- a/x/gov/keeper/vote_test.go +++ b/x/gov/keeper/vote_test.go @@ -11,7 +11,7 @@ import ( ) func TestVotes(t *testing.T) { - govKeeper, _, bankKeeper, stakingKeeper, _, ctx := setupGovKeeper(t) + govKeeper, _, bankKeeper, stakingKeeper, _, _, ctx := setupGovKeeper(t) addrs := simtestutil.AddTestAddrsIncremental(bankKeeper, stakingKeeper, ctx, 2, sdk.NewInt(10000000)) tp := TestProposal diff --git a/x/gov/migrations/v4/json.go b/x/gov/migrations/v4/json.go index 6ae35e9e3a3..9add416e3eb 100644 --- a/x/gov/migrations/v4/json.go +++ b/x/gov/migrations/v4/json.go @@ -19,6 +19,8 @@ func MigrateJSON(oldState *v1.GenesisState) (*v1.GenesisState, error) { oldState.TallyParams.Threshold, oldState.TallyParams.VetoThreshold, v1.DefaultParams().MinInitialDepositRatio, + v1.DefaultParams().ProposalCancelRatio, + v1.DefaultParams().ProposalCancelDest, ) return &v1.GenesisState{ diff --git a/x/gov/migrations/v4/json_test.go b/x/gov/migrations/v4/json_test.go index d6a48b7a3ff..959dfd61f85 100644 --- a/x/gov/migrations/v4/json_test.go +++ b/x/gov/migrations/v4/json_test.go @@ -67,6 +67,8 @@ func TestMigrateJSON(t *testing.T) { } ], "min_initial_deposit_ratio": "0.000000000000000000", + "proposal_cancel_dest": "", + "proposal_cancel_ratio": "0.500000000000000000", "quorum": "0.334000000000000000", "threshold": "0.500000000000000000", "veto_threshold": "0.334000000000000000", diff --git a/x/gov/migrations/v4/store.go b/x/gov/migrations/v4/store.go index eb8ebc5004c..c353dec1ed5 100644 --- a/x/gov/migrations/v4/store.go +++ b/x/gov/migrations/v4/store.go @@ -28,6 +28,8 @@ func migrateParams(ctx sdk.Context, storeKey storetypes.StoreKey, legacySubspace tp.Threshold, tp.VetoThreshold, sdk.ZeroDec().String(), + sdk.ZeroDec().String(), + "", ) bz, err := cdc.Marshal(¶ms) diff --git a/x/gov/migrations/v5/store.go b/x/gov/migrations/v5/store.go new file mode 100644 index 00000000000..2888aa460e9 --- /dev/null +++ b/x/gov/migrations/v5/store.go @@ -0,0 +1,61 @@ +package v5 + +import ( + "fmt" + "sort" + + "github.com/cosmos/cosmos-sdk/codec" + storetypes "github.com/cosmos/cosmos-sdk/store/types" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/gov/types" + govv1 "github.com/cosmos/cosmos-sdk/x/gov/types/v1" +) + +// AddProposerAddressToProposal will add proposer to proposal +// and set to the store. This function is optional, and only needed +// if you wish that migrated proposals be cancellable. +func AddProposerAddressToProposal(ctx sdk.Context, storeKey storetypes.StoreKey, cdc codec.BinaryCodec, proposals map[uint64]string) error { + proposalIDs := make([]uint64, 0, len(proposals)) + + for proposalID := range proposals { + proposalIDs = append(proposalIDs, proposalID) + } + + // sort the proposalIDs + sort.Slice(proposalIDs, func(i, j int) bool { return proposalIDs[i] < proposalIDs[j] }) + + store := ctx.KVStore(storeKey) + + for _, proposalID := range proposalIDs { + if len(proposals[proposalID]) == 0 { + return fmt.Errorf("found missing proposer for proposal ID: %d", proposalID) + } + + if _, err := sdk.AccAddressFromBech32(proposals[proposalID]); err != nil { + return fmt.Errorf("invalid proposer address : %s", proposals[proposalID]) + } + + bz := store.Get(types.ProposalKey(proposalID)) + var proposal govv1.Proposal + if err := cdc.Unmarshal(bz, &proposal); err != nil { + panic(err) + } + + // Check if proposal is active + if proposal.Status != govv1.ProposalStatus_PROPOSAL_STATUS_VOTING_PERIOD && + proposal.Status != govv1.ProposalStatus_PROPOSAL_STATUS_DEPOSIT_PERIOD { + return fmt.Errorf("invalid proposal : %s, proposal not active", proposals[proposalID]) + } + + proposal.Proposer = proposals[proposalID] + + // set the new proposal with proposer + bz, err := cdc.Marshal(&proposal) + if err != nil { + panic(err) + } + store.Set(types.ProposalKey(proposal.Id), bz) + } + + return nil +} diff --git a/x/gov/module.go b/x/gov/module.go index 7f7b5e7a475..d5f7f4ac814 100644 --- a/x/gov/module.go +++ b/x/gov/module.go @@ -170,9 +170,10 @@ type GovInputs struct { ModuleKey depinject.OwnModuleKey MsgServiceRouter *baseapp.MsgServiceRouter - AccountKeeper govtypes.AccountKeeper - BankKeeper govtypes.BankKeeper - StakingKeeper govtypes.StakingKeeper + AccountKeeper govtypes.AccountKeeper + BankKeeper govtypes.BankKeeper + StakingKeeper govtypes.StakingKeeper + DistributionKeeper govtypes.DistributionKeeper // LegacySubspace is used solely for migration of x/params managed parameters LegacySubspace govtypes.ParamSubspace @@ -205,6 +206,7 @@ func ProvideModule(in GovInputs) GovOutputs { in.AccountKeeper, in.BankKeeper, in.StakingKeeper, + in.DistributionKeeper, in.MsgServiceRouter, defaultConfig, authority.String(), diff --git a/x/gov/simulation/genesis.go b/x/gov/simulation/genesis.go index 5d276b1cade..706214505c1 100644 --- a/x/gov/simulation/genesis.go +++ b/x/gov/simulation/genesis.go @@ -24,6 +24,7 @@ const ( TallyParamsQuorum = "tally_params_quorum" TallyParamsThreshold = "tally_params_threshold" TallyParamsVeto = "tally_params_veto" + ProposalCancelRate = "proposal_cancel_rate" ) // GenDepositParamsDepositPeriod returns randomized DepositParamsDepositPeriod @@ -41,6 +42,11 @@ func GenDepositMinInitialDepositRatio(r *rand.Rand) sdk.Dec { return sdk.NewDec(int64(simulation.RandIntBetween(r, 0, 99))).Quo(sdk.NewDec(100)) } +// GenProposalCancelRate returns randomized ProposalCancelRate +func GenProposalCancelRate(r *rand.Rand) sdk.Dec { + return sdk.NewDec(int64(simulation.RandIntBetween(r, 0, 99))).Quo(sdk.NewDec(100)) +} + // GenVotingParamsVotingPeriod returns randomized VotingParamsVotingPeriod func GenVotingParamsVotingPeriod(r *rand.Rand) time.Duration { return time.Duration(simulation.RandIntBetween(r, 1, 2*60*60*24*2)) * time.Second @@ -83,6 +89,12 @@ func RandomizedGenState(simState *module.SimulationState) { func(r *rand.Rand) { minInitialDepositRatio = GenDepositMinInitialDepositRatio(r) }, ) + var proposalCancelRate sdk.Dec + simState.AppParams.GetOrGenerate( + simState.Cdc, ProposalCancelRate, &proposalCancelRate, simState.Rand, + func(r *rand.Rand) { proposalCancelRate = GenProposalCancelRate(r) }, + ) + var votingPeriod time.Duration simState.AppParams.GetOrGenerate( simState.Cdc, VotingParamsVotingPeriod, &votingPeriod, simState.Rand, @@ -109,7 +121,7 @@ func RandomizedGenState(simState *module.SimulationState) { govGenesis := v1.NewGenesisState( startingProposalID, - v1.NewParams(minDeposit, depositPeriod, votingPeriod, quorum.String(), threshold.String(), veto.String(), minInitialDepositRatio.String()), + v1.NewParams(minDeposit, depositPeriod, votingPeriod, quorum.String(), threshold.String(), veto.String(), minInitialDepositRatio.String(), proposalCancelRate.String(), ""), ) bz, err := json.MarshalIndent(&govGenesis, "", " ") diff --git a/x/gov/simulation/genesis_test.go b/x/gov/simulation/genesis_test.go index 70a74742bbd..3867358b2b9 100644 --- a/x/gov/simulation/genesis_test.go +++ b/x/gov/simulation/genesis_test.go @@ -44,15 +44,15 @@ func TestRandomizedGenState(t *testing.T) { simState.Cdc.MustUnmarshalJSON(simState.GenState[types.ModuleName], &govGenesis) const ( - tallyQuorum = "0.400000000000000000" - tallyThreshold = "0.539000000000000000" - tallyVetoThreshold = "0.314000000000000000" + tallyQuorum = "0.375000000000000000" + tallyThreshold = "0.478000000000000000" + tallyVetoThreshold = "0.324000000000000000" minInitialDepositDec = "0.590000000000000000" ) require.Equal(t, "905stake", govGenesis.Params.MinDeposit[0].String()) require.Equal(t, "77h26m10s", govGenesis.Params.MaxDepositPeriod.String()) - require.Equal(t, float64(275567), govGenesis.Params.VotingPeriod.Seconds()) + require.Equal(t, float64(135894), govGenesis.Params.VotingPeriod.Seconds()) require.Equal(t, tallyQuorum, govGenesis.Params.Quorum) require.Equal(t, tallyThreshold, govGenesis.Params.Threshold) require.Equal(t, tallyVetoThreshold, govGenesis.Params.VetoThreshold) diff --git a/x/gov/simulation/operations.go b/x/gov/simulation/operations.go index 09a56b44454..47f81408c7a 100644 --- a/x/gov/simulation/operations.go +++ b/x/gov/simulation/operations.go @@ -25,28 +25,32 @@ var ( TypeMsgVote = sdk.MsgTypeURL(&v1.MsgVote{}) TypeMsgVoteWeighted = sdk.MsgTypeURL(&v1.MsgVoteWeighted{}) TypeMsgSubmitProposal = sdk.MsgTypeURL(&v1.MsgSubmitProposal{}) + TypeMsgCancelProposal = sdk.MsgTypeURL(&v1.MsgCancelProposal{}) ) // Simulation operation weights constants // //nolint:gosec // these are not hard-coded credentials. const ( - OpWeightMsgDeposit = "op_weight_msg_deposit" - OpWeightMsgVote = "op_weight_msg_vote" - OpWeightMsgVoteWeighted = "op_weight_msg_weighted_vote" - - DefaultWeightMsgDeposit = 100 - DefaultWeightMsgVote = 67 - DefaultWeightMsgVoteWeighted = 33 - DefaultWeightTextProposal = 5 + OpWeightMsgDeposit = "op_weight_msg_deposit" + OpWeightMsgVote = "op_weight_msg_vote" + OpWeightMsgVoteWeighted = "op_weight_msg_weighted_vote" + OpWeightMsgCancelProposal = "op_weight_msg_cancel_proposal" + + DefaultWeightMsgDeposit = 100 + DefaultWeightMsgVote = 67 + DefaultWeightMsgVoteWeighted = 33 + DefaultWeightTextProposal = 5 + DefaultWeightMsgCancelProposal = 5 ) // WeightedOperations returns all the operations from the module with their respective weights func WeightedOperations(appParams simtypes.AppParams, cdc codec.JSONCodec, ak types.AccountKeeper, bk types.BankKeeper, k *keeper.Keeper, wContents []simtypes.WeightedProposalContent) simulation.WeightedOperations { var ( - weightMsgDeposit int - weightMsgVote int - weightMsgVoteWeighted int + weightMsgDeposit int + weightMsgVote int + weightMsgVoteWeighted int + weightMsgCancelProposal int ) appParams.GetOrGenerate(cdc, OpWeightMsgDeposit, &weightMsgDeposit, nil, @@ -67,6 +71,12 @@ func WeightedOperations(appParams simtypes.AppParams, cdc codec.JSONCodec, ak ty }, ) + appParams.GetOrGenerate(cdc, OpWeightMsgCancelProposal, &weightMsgCancelProposal, nil, + func(_ *rand.Rand) { + weightMsgCancelProposal = DefaultWeightMsgCancelProposal + }, + ) + // generate the weighted operations for the proposal contents var wProposalOps simulation.WeightedOperations @@ -98,6 +108,10 @@ func WeightedOperations(appParams simtypes.AppParams, cdc codec.JSONCodec, ak ty weightMsgVoteWeighted, SimulateMsgVoteWeighted(ak, bk, k), ), + simulation.NewWeightedOperation( + weightMsgCancelProposal, + SimulateMsgCancelProposal(ak, bk, k), + ), } return append(wProposalOps, wGovOps...) @@ -379,6 +393,46 @@ func operationSimulateMsgVoteWeighted(ak types.AccountKeeper, bk types.BankKeepe } } +// SimulateMsgCancelProposal generates a MsgCancelProposal. +func SimulateMsgCancelProposal(ak types.AccountKeeper, bk types.BankKeeper, k *keeper.Keeper) simtypes.Operation { + return func( + r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, + accs []simtypes.Account, chainID string, + ) (simtypes.OperationMsg, []simtypes.FutureOperation, error) { + simAccount := accs[0] + proposal := randomProposal(r, k, ctx) + if proposal == nil { + return simtypes.NoOpMsg(types.ModuleName, TypeMsgCancelProposal, "no proposals found"), nil, nil + } + + if proposal.Proposer != simAccount.Address.String() { + return simtypes.NoOpMsg(types.ModuleName, TypeMsgCancelProposal, "invalid proposer"), nil, nil + } + + account := ak.GetAccount(ctx, simAccount.Address) + spendable := bk.SpendableCoins(ctx, account.GetAddress()) + + msg := v1.NewMsgCancelProposal(proposal.Id, account.GetAddress().String()) + + txCtx := simulation.OperationInput{ + R: r, + App: app, + TxGen: moduletestutil.MakeTestEncodingConfig().TxConfig, + Cdc: nil, + Msg: msg, + MsgType: msg.Type(), + Context: ctx, + SimAccount: simAccount, + AccountKeeper: ak, + Bankkeeper: bk, + ModuleName: types.ModuleName, + CoinsSpentInMsg: spendable, + } + + return simulation.GenAndDeliverTxWithRandFees(txCtx) + } +} + // Pick a random deposit with a random denomination with a // deposit amount between (0, min(balance, minDepositAmount)) // This is to simulate multiple users depositing to get the @@ -434,6 +488,16 @@ func randomDeposit( return sdk.Coins{sdk.NewCoin(denom, amount)}, false, nil } +// randomProposal +func randomProposal(r *rand.Rand, k *keeper.Keeper, ctx sdk.Context) *v1.Proposal { + proposals := k.GetProposals(ctx) + if len(proposals) == 0 { + return nil + } + randomIndex := r.Intn(len(proposals)) + return proposals[randomIndex] +} + // Pick a random proposal ID between the initial proposal ID // (defined in gov GenesisState) and the latest proposal ID // that matches a given Status. diff --git a/x/gov/simulation/operations_test.go b/x/gov/simulation/operations_test.go index 809fabde49f..4506314c9aa 100644 --- a/x/gov/simulation/operations_test.go +++ b/x/gov/simulation/operations_test.go @@ -23,6 +23,8 @@ import ( bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper" "github.com/cosmos/cosmos-sdk/x/bank/testutil" _ "github.com/cosmos/cosmos-sdk/x/consensus" + _ "github.com/cosmos/cosmos-sdk/x/distribution" + dk "github.com/cosmos/cosmos-sdk/x/distribution/keeper" govcodec "github.com/cosmos/cosmos-sdk/x/gov/codec" "github.com/cosmos/cosmos-sdk/x/gov/keeper" "github.com/cosmos/cosmos-sdk/x/gov/simulation" @@ -95,6 +97,7 @@ func TestWeightedOperations(t *testing.T) { {simulation.DefaultWeightMsgDeposit, types.ModuleName, simulation.TypeMsgDeposit}, {simulation.DefaultWeightMsgVote, types.ModuleName, simulation.TypeMsgVote}, {simulation.DefaultWeightMsgVoteWeighted, types.ModuleName, simulation.TypeMsgVoteWeighted}, + {simulation.DefaultWeightMsgCancelProposal, types.ModuleName, simulation.TypeMsgCancelProposal}, } for i, w := range weightesOps { @@ -143,6 +146,51 @@ func TestSimulateMsgSubmitProposal(t *testing.T) { require.Equal(t, simulation.TypeMsgSubmitProposal, msg.Type()) } +// TestSimulateMsgCancelProposal tests the normal scenario of a valid message of type TypeMsgCancelProposal. +// Abnormal scenarios, where errors occur, are not tested here. +func TestSimulateMsgCancelProposal(t *testing.T) { + suite, ctx := createTestSuite(t, false) + app := suite.App + blockTime := time.Now().UTC() + ctx = ctx.WithBlockTime(blockTime) + + // setup 3 accounts + s := rand.NewSource(1) + r := rand.New(s) + accounts := getTestingAccounts(t, r, suite.AccountKeeper, suite.BankKeeper, suite.StakingKeeper, ctx, 3) + // setup a proposal + proposer := accounts[0].Address + content := v1beta1.NewTextProposal("Test", "description") + contentMsg, err := v1.NewLegacyContent(content, suite.GovKeeper.GetGovernanceAccount(ctx).GetAddress().String()) + require.NoError(t, err) + + submitTime := ctx.BlockHeader().Time + depositPeriod := suite.GovKeeper.GetParams(ctx).MaxDepositPeriod + + proposal, err := v1.NewProposal([]sdk.Msg{contentMsg}, 1, "", submitTime, submitTime.Add(*depositPeriod), "title", "summary", proposer) + require.NoError(t, err) + + suite.GovKeeper.SetProposal(ctx, proposal) + + // begin a new block + app.BeginBlock(abci.RequestBeginBlock{Header: tmproto.Header{Height: app.LastBlockHeight() + 1, AppHash: app.LastCommitID().Hash, Time: blockTime}}) + + // execute operation + op := simulation.SimulateMsgCancelProposal(suite.AccountKeeper, suite.BankKeeper, suite.GovKeeper) + operationMsg, _, err := op(r, app.BaseApp, ctx, accounts, "") + require.NoError(t, err) + + var msg v1.MsgCancelProposal + err = govcodec.ModuleCdc.UnmarshalJSON(operationMsg.Msg, &msg) + require.NoError(t, err) + + require.True(t, operationMsg.OK) + require.Equal(t, uint64(1), msg.ProposalId) + require.Equal(t, proposer.String(), msg.Proposer) + require.Equal(t, "gov", msg.Route()) + require.Equal(t, simulation.TypeMsgCancelProposal, msg.Type()) +} + // TestSimulateMsgDeposit tests the normal scenario of a valid message of type TypeMsgDeposit. // Abnormal scenarios, where errors occur, are not tested here. func TestSimulateMsgDeposit(t *testing.T) { @@ -280,12 +328,13 @@ func TestSimulateMsgVoteWeighted(t *testing.T) { } type suite struct { - cdc codec.Codec - AccountKeeper authkeeper.AccountKeeper - BankKeeper bankkeeper.Keeper - GovKeeper *keeper.Keeper - StakingKeeper *stakingkeeper.Keeper - App *runtime.App + cdc codec.Codec + AccountKeeper authkeeper.AccountKeeper + BankKeeper bankkeeper.Keeper + GovKeeper *keeper.Keeper + StakingKeeper *stakingkeeper.Keeper + DistributionKeeper dk.Keeper + App *runtime.App } // returns context and an app with updated mint keeper @@ -299,8 +348,9 @@ func createTestSuite(t *testing.T, isCheckTx bool) (suite, sdk.Context) { configurator.BankModule(), configurator.StakingModule(), configurator.ConsensusModule(), + configurator.DistributionModule(), configurator.GovModule(), - ), &res.AccountKeeper, &res.BankKeeper, &res.GovKeeper, &res.StakingKeeper, &res.cdc) + ), &res.AccountKeeper, &res.BankKeeper, &res.GovKeeper, &res.StakingKeeper, &res.DistributionKeeper, &res.cdc) require.NoError(t, err) ctx := app.BaseApp.NewContext(isCheckTx, tmproto.Header{}) diff --git a/x/gov/testutil/expected_keepers.go b/x/gov/testutil/expected_keepers.go index 50ace59c661..312c8292c43 100644 --- a/x/gov/testutil/expected_keepers.go +++ b/x/gov/testutil/expected_keepers.go @@ -32,3 +32,8 @@ type StakingKeeper interface { BondDenom(ctx sdk.Context) string TokensFromConsensusPower(ctx sdk.Context, power int64) math.Int } + +// DistributionKeeper defines the expected distribution keeper +type DistributionKeeper interface { + FundCommunityPool(ctx sdk.Context, amount sdk.Coins, sender sdk.AccAddress) error +} diff --git a/x/gov/testutil/expected_keepers_mocks.go b/x/gov/testutil/expected_keepers_mocks.go index 451a0882fbd..898ffb06eb0 100644 --- a/x/gov/testutil/expected_keepers_mocks.go +++ b/x/gov/testutil/expected_keepers_mocks.go @@ -1020,3 +1020,40 @@ func (mr *MockStakingKeeperMockRecorder) TotalBondedTokens(arg0 interface{}) *go mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TotalBondedTokens", reflect.TypeOf((*MockStakingKeeper)(nil).TotalBondedTokens), arg0) } + +// MockDistributionKeeper is a mock of DistributionKeeper interface. +type MockDistributionKeeper struct { + ctrl *gomock.Controller + recorder *MockDistributionKeeperMockRecorder +} + +// MockDistributionKeeperMockRecorder is the mock recorder for MockDistributionKeeper. +type MockDistributionKeeperMockRecorder struct { + mock *MockDistributionKeeper +} + +// NewMockDistributionKeeper creates a new mock instance. +func NewMockDistributionKeeper(ctrl *gomock.Controller) *MockDistributionKeeper { + mock := &MockDistributionKeeper{ctrl: ctrl} + mock.recorder = &MockDistributionKeeperMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockDistributionKeeper) EXPECT() *MockDistributionKeeperMockRecorder { + return m.recorder +} + +// FundCommunityPool mocks base method. +func (m *MockDistributionKeeper) FundCommunityPool(ctx types.Context, amount types.Coins, sender types.AccAddress) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FundCommunityPool", ctx, amount, sender) + ret0, _ := ret[0].(error) + return ret0 +} + +// FundCommunityPool indicates an expected call of FundCommunityPool. +func (mr *MockDistributionKeeperMockRecorder) FundCommunityPool(ctx, amount, sender interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FundCommunityPool", reflect.TypeOf((*MockDistributionKeeper)(nil).FundCommunityPool), ctx, amount, sender) +} diff --git a/x/gov/types/errors.go b/x/gov/types/errors.go index eb14067caa1..b7496b59f21 100644 --- a/x/gov/types/errors.go +++ b/x/gov/types/errors.go @@ -22,4 +22,9 @@ var ( ErrInvalidSignalMsg = sdkerrors.Register(ModuleName, 14, "signal message is invalid") ErrMetadataTooLong = sdkerrors.Register(ModuleName, 15, "metadata too long") ErrMinDepositTooSmall = sdkerrors.Register(ModuleName, 16, "minimum deposit is too small") + ErrProposalNotFound = sdkerrors.Register(ModuleName, 17, "proposal is not found") + ErrInvalidProposer = sdkerrors.Register(ModuleName, 18, "invalid proposer") + ErrNoDeposits = sdkerrors.Register(ModuleName, 19, "no deposits found") + ErrVotingPeriodEnded = sdkerrors.Register(ModuleName, 20, "voting period already ended") + ErrInvalidProposal = sdkerrors.Register(ModuleName, 21, "invalid proposal") ) diff --git a/x/gov/types/events.go b/x/gov/types/events.go index 76927591af8..148d698b212 100644 --- a/x/gov/types/events.go +++ b/x/gov/types/events.go @@ -8,6 +8,7 @@ const ( EventTypeInactiveProposal = "inactive_proposal" EventTypeActiveProposal = "active_proposal" EventTypeSignalProposal = "signal_proposal" + EventTypeCancelProposal = "cancel_proposal" AttributeKeyProposalResult = "proposal_result" AttributeKeyOption = "option" @@ -18,7 +19,9 @@ const ( AttributeValueProposalPassed = "proposal_passed" // met vote quorum AttributeValueProposalRejected = "proposal_rejected" // didn't meet vote quorum AttributeValueProposalFailed = "proposal_failed" // error on proposal handler - AttributeKeyProposalType = "proposal_type" - AttributeSignalTitle = "signal_title" - AttributeSignalDescription = "signal_description" + AttributeValueProposalCanceled = "proposal_canceled" // error on proposal handler + + AttributeKeyProposalType = "proposal_type" + AttributeSignalTitle = "signal_title" + AttributeSignalDescription = "signal_description" ) diff --git a/x/gov/types/expected_keepers.go b/x/gov/types/expected_keepers.go index 23add0cfd0b..94b35219da7 100644 --- a/x/gov/types/expected_keepers.go +++ b/x/gov/types/expected_keepers.go @@ -27,6 +27,11 @@ type StakingKeeper interface { ) } +// DistributionKeeper defines the expected distribution keeper (noalias) +type DistributionKeeper interface { + FundCommunityPool(ctx sdk.Context, amount sdk.Coins, sender sdk.AccAddress) error +} + // AccountKeeper defines the expected account keeper (noalias) type AccountKeeper interface { GetAccount(ctx sdk.Context, addr sdk.AccAddress) sdk.AccountI diff --git a/x/gov/types/v1/gov.pb.go b/x/gov/types/v1/gov.pb.go index af5e907e52b..b16e1babe7c 100644 --- a/x/gov/types/v1/gov.pb.go +++ b/x/gov/types/v1/gov.pb.go @@ -739,6 +739,15 @@ type Params struct { VetoThreshold string `protobuf:"bytes,6,opt,name=veto_threshold,json=vetoThreshold,proto3" json:"veto_threshold,omitempty"` // The ratio representing the proportion of the deposit value that must be paid at proposal submission. MinInitialDepositRatio string `protobuf:"bytes,7,opt,name=min_initial_deposit_ratio,json=minInitialDepositRatio,proto3" json:"min_initial_deposit_ratio,omitempty"` + // The cancel ratio which will not be returned back to the depositors when a proposal is cancelled. + // + // Since: cosmos-sdk 0.48 + ProposalCancelRatio string `protobuf:"bytes,8,opt,name=proposal_cancel_ratio,json=proposalCancelRatio,proto3" json:"proposal_cancel_ratio,omitempty"` + // The address which will receive (proposal_cancel_ratio * deposit) proposal deposits. + // If empty, the (proposal_cancel_ratio * deposit) proposal deposits will be burned. + // + // Since: cosmos-sdk 0.48 + ProposalCancelDest string `protobuf:"bytes,9,opt,name=proposal_cancel_dest,json=proposalCancelDest,proto3" json:"proposal_cancel_dest,omitempty"` } func (m *Params) Reset() { *m = Params{} } @@ -823,6 +832,20 @@ func (m *Params) GetMinInitialDepositRatio() string { return "" } +func (m *Params) GetProposalCancelRatio() string { + if m != nil { + return m.ProposalCancelRatio + } + return "" +} + +func (m *Params) GetProposalCancelDest() string { + if m != nil { + return m.ProposalCancelDest + } + return "" +} + func init() { proto.RegisterEnum("cosmos.gov.v1.VoteOption", VoteOption_name, VoteOption_value) proto.RegisterEnum("cosmos.gov.v1.ProposalStatus", ProposalStatus_name, ProposalStatus_value) @@ -840,83 +863,86 @@ func init() { func init() { proto.RegisterFile("cosmos/gov/v1/gov.proto", fileDescriptor_e05cb1c0d030febb) } var fileDescriptor_e05cb1c0d030febb = []byte{ - // 1212 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x56, 0x3f, 0x73, 0x13, 0x47, - 0x14, 0xf7, 0x49, 0x27, 0x59, 0x7e, 0xb2, 0x84, 0x58, 0x1c, 0x38, 0x1b, 0x90, 0x8c, 0x26, 0xc3, - 0x38, 0xfc, 0x91, 0x62, 0x08, 0x69, 0x48, 0x23, 0x5b, 0x47, 0x38, 0x86, 0x58, 0x9a, 0xd3, 0x61, - 0x86, 0x34, 0x37, 0x6b, 0xdf, 0x22, 0xed, 0x44, 0x77, 0xab, 0xdc, 0xae, 0x04, 0xfa, 0x08, 0xe9, - 0x28, 0x33, 0xa9, 0x52, 0xa6, 0x4c, 0xc1, 0xa4, 0x4a, 0x93, 0x8e, 0x2a, 0xc3, 0xd0, 0x24, 0x69, - 0x48, 0x06, 0x8a, 0xcc, 0xf0, 0x29, 0x32, 0xb7, 0xb7, 0x67, 0xc9, 0xb2, 0x32, 0x36, 0x34, 0xd2, - 0xed, 0x7b, 0xbf, 0xdf, 0x7b, 0x6f, 0xdf, 0x9f, 0xdd, 0x85, 0x73, 0xfb, 0x8c, 0xfb, 0x8c, 0xd7, - 0xbb, 0x6c, 0x54, 0x1f, 0x6d, 0x46, 0x7f, 0xb5, 0x41, 0xc8, 0x04, 0x43, 0x85, 0x58, 0x51, 0x8b, - 0x24, 0xa3, 0xcd, 0xb5, 0xb2, 0xc2, 0xed, 0x61, 0x4e, 0xea, 0xa3, 0xcd, 0x3d, 0x22, 0xf0, 0x66, - 0x7d, 0x9f, 0xd1, 0x20, 0x86, 0xaf, 0xad, 0x74, 0x59, 0x97, 0xc9, 0xcf, 0x7a, 0xf4, 0xa5, 0xa4, - 0x95, 0x2e, 0x63, 0xdd, 0x3e, 0xa9, 0xcb, 0xd5, 0xde, 0xf0, 0x71, 0x5d, 0x50, 0x9f, 0x70, 0x81, - 0xfd, 0x81, 0x02, 0xac, 0xce, 0x02, 0x70, 0x30, 0x56, 0xaa, 0xf2, 0xac, 0xca, 0x1b, 0x86, 0x58, - 0x50, 0x96, 0x78, 0x5c, 0x8d, 0x23, 0x72, 0x63, 0xa7, 0x2a, 0xda, 0x58, 0x75, 0x1a, 0xfb, 0x34, - 0x60, 0x75, 0xf9, 0x1b, 0x8b, 0xaa, 0x0c, 0xd0, 0x43, 0x42, 0xbb, 0x3d, 0x41, 0xbc, 0x5d, 0x26, - 0x48, 0x6b, 0x10, 0x59, 0x42, 0x9b, 0x90, 0x65, 0xf2, 0xcb, 0xd0, 0xd6, 0xb5, 0x8d, 0xe2, 0x8d, - 0xd5, 0xda, 0xa1, 0x5d, 0xd7, 0x26, 0x50, 0x5b, 0x01, 0xd1, 0x65, 0xc8, 0x3e, 0x91, 0x86, 0x8c, - 0xd4, 0xba, 0xb6, 0xb1, 0xb4, 0x55, 0x7c, 0xf5, 0xfc, 0x3a, 0x28, 0x56, 0x93, 0xec, 0xdb, 0x4a, - 0x5b, 0xfd, 0x51, 0x83, 0xc5, 0x26, 0x19, 0x30, 0x4e, 0x05, 0xaa, 0x40, 0x7e, 0x10, 0xb2, 0x01, - 0xe3, 0xb8, 0xef, 0x52, 0x4f, 0xfa, 0xd2, 0x6d, 0x48, 0x44, 0x96, 0x87, 0x3e, 0x87, 0x25, 0x2f, - 0xc6, 0xb2, 0x50, 0xd9, 0x35, 0x5e, 0x3d, 0xbf, 0xbe, 0xa2, 0xec, 0x36, 0x3c, 0x2f, 0x24, 0x9c, - 0x77, 0x44, 0x48, 0x83, 0xae, 0x3d, 0x81, 0xa2, 0x2f, 0x20, 0x8b, 0x7d, 0x36, 0x0c, 0x84, 0x91, - 0x5e, 0x4f, 0x6f, 0xe4, 0x27, 0xf1, 0x47, 0x65, 0xaa, 0xa9, 0x32, 0xd5, 0xb6, 0x19, 0x0d, 0xb6, - 0x96, 0x5e, 0xbc, 0xae, 0x2c, 0xfc, 0xf4, 0xef, 0xcf, 0x57, 0x34, 0x5b, 0x71, 0xaa, 0xbf, 0x65, - 0x20, 0xd7, 0x56, 0x41, 0xa0, 0x22, 0xa4, 0x0e, 0x42, 0x4b, 0x51, 0x0f, 0x7d, 0x0a, 0x39, 0x9f, - 0x70, 0x8e, 0xbb, 0x84, 0x1b, 0x29, 0x69, 0x7c, 0xa5, 0x16, 0x57, 0xa4, 0x96, 0x54, 0xa4, 0xd6, - 0x08, 0xc6, 0xf6, 0x01, 0x0a, 0xdd, 0x82, 0x2c, 0x17, 0x58, 0x0c, 0xb9, 0x91, 0x96, 0xc9, 0xbc, - 0x38, 0x93, 0xcc, 0xc4, 0x55, 0x47, 0x82, 0x6c, 0x05, 0x46, 0x77, 0x01, 0x3d, 0xa6, 0x01, 0xee, - 0xbb, 0x02, 0xf7, 0xfb, 0x63, 0x37, 0x24, 0x7c, 0xd8, 0x17, 0x86, 0xbe, 0xae, 0x6d, 0xe4, 0x6f, - 0xac, 0xcd, 0x98, 0x70, 0x22, 0x88, 0x2d, 0x11, 0x76, 0x49, 0xb2, 0xa6, 0x24, 0xa8, 0x01, 0x79, - 0x3e, 0xdc, 0xf3, 0xa9, 0x70, 0xa3, 0x36, 0x33, 0x32, 0xca, 0xc4, 0x6c, 0xd4, 0x4e, 0xd2, 0x83, - 0x5b, 0xfa, 0xb3, 0xbf, 0x2b, 0x9a, 0x0d, 0x31, 0x29, 0x12, 0xa3, 0x7b, 0x50, 0x52, 0xd9, 0x75, - 0x49, 0xe0, 0xc5, 0x76, 0xb2, 0x27, 0xb4, 0x53, 0x54, 0x4c, 0x33, 0xf0, 0xa4, 0x2d, 0x0b, 0x0a, - 0x82, 0x09, 0xdc, 0x77, 0x95, 0xdc, 0x58, 0x7c, 0x8f, 0x1a, 0x2d, 0x4b, 0x6a, 0xd2, 0x40, 0xf7, - 0xe1, 0xf4, 0x88, 0x09, 0x1a, 0x74, 0x5d, 0x2e, 0x70, 0xa8, 0xf6, 0x97, 0x3b, 0x61, 0x5c, 0xa7, - 0x62, 0x6a, 0x27, 0x62, 0xca, 0xc0, 0xee, 0x82, 0x12, 0x4d, 0xf6, 0xb8, 0x74, 0x42, 0x5b, 0x85, - 0x98, 0x98, 0x6c, 0x71, 0x2d, 0x6a, 0x12, 0x81, 0x3d, 0x2c, 0xb0, 0x01, 0x51, 0xdb, 0xda, 0x07, - 0x6b, 0xb4, 0x02, 0x19, 0x41, 0x45, 0x9f, 0x18, 0x79, 0xa9, 0x88, 0x17, 0xc8, 0x80, 0x45, 0x3e, - 0xf4, 0x7d, 0x1c, 0x8e, 0x8d, 0x65, 0x29, 0x4f, 0x96, 0xe8, 0x33, 0xc8, 0xc5, 0x13, 0x41, 0x42, - 0xa3, 0x70, 0xcc, 0x08, 0x1c, 0x20, 0xab, 0x7f, 0x68, 0x90, 0x9f, 0xee, 0x81, 0xab, 0xb0, 0x34, - 0x26, 0xdc, 0xdd, 0x97, 0x43, 0xa1, 0x1d, 0x99, 0x50, 0x2b, 0x10, 0x76, 0x6e, 0x4c, 0xf8, 0x76, - 0xa4, 0x47, 0x37, 0xa1, 0x80, 0xf7, 0xb8, 0xc0, 0x34, 0x50, 0x84, 0xd4, 0x5c, 0xc2, 0xb2, 0x02, - 0xc5, 0xa4, 0x4f, 0x20, 0x17, 0x30, 0x85, 0x4f, 0xcf, 0xc5, 0x2f, 0x06, 0x2c, 0x86, 0xde, 0x06, - 0x14, 0x30, 0xf7, 0x09, 0x15, 0x3d, 0x77, 0x44, 0x44, 0x42, 0xd2, 0xe7, 0x92, 0x4e, 0x05, 0xec, - 0x21, 0x15, 0xbd, 0x5d, 0x22, 0x62, 0x72, 0xf5, 0x17, 0x0d, 0xf4, 0xe8, 0xfc, 0x39, 0xfe, 0xf4, - 0xa8, 0x41, 0x66, 0xc4, 0x04, 0x39, 0xfe, 0xe4, 0x88, 0x61, 0xe8, 0x36, 0x2c, 0xc6, 0x87, 0x19, - 0x37, 0x74, 0xd9, 0x92, 0x97, 0x66, 0xc6, 0xec, 0xe8, 0x49, 0x69, 0x27, 0x8c, 0x43, 0x25, 0xcf, - 0x1c, 0x2e, 0xf9, 0x3d, 0x3d, 0x97, 0x2e, 0xe9, 0xd5, 0xbf, 0x34, 0x28, 0xa8, 0xc6, 0x6d, 0xe3, - 0x10, 0xfb, 0x1c, 0x3d, 0x82, 0xbc, 0x4f, 0x83, 0x83, 0x39, 0xd0, 0x8e, 0x9b, 0x83, 0x8b, 0xd1, - 0x1c, 0xbc, 0x7b, 0x5d, 0xf9, 0x68, 0x8a, 0x75, 0x8d, 0xf9, 0x54, 0x10, 0x7f, 0x20, 0xc6, 0x36, - 0xf8, 0x34, 0x48, 0x26, 0xc3, 0x07, 0xe4, 0xe3, 0xa7, 0x09, 0xc8, 0x1d, 0x90, 0x90, 0x32, 0x4f, - 0x26, 0x22, 0xf2, 0x30, 0xdb, 0xce, 0x4d, 0x75, 0x85, 0x6c, 0x7d, 0xfc, 0xee, 0x75, 0xe5, 0xc2, - 0x51, 0xe2, 0xc4, 0xc9, 0xf7, 0x51, 0xb7, 0x97, 0x7c, 0xfc, 0x34, 0xd9, 0x89, 0xd4, 0x57, 0x1d, - 0x58, 0xde, 0x95, 0x13, 0xa0, 0x76, 0xd6, 0x04, 0x35, 0x11, 0x89, 0x67, 0xed, 0x38, 0xcf, 0xba, - 0xb4, 0xbc, 0x1c, 0xb3, 0x94, 0xd5, 0x1f, 0x92, 0x26, 0x56, 0x56, 0x2f, 0x43, 0xf6, 0xdb, 0x21, - 0x0b, 0x87, 0xfe, 0x9c, 0x0e, 0x96, 0x77, 0x4c, 0xac, 0x45, 0xd7, 0x60, 0x49, 0xf4, 0x42, 0xc2, - 0x7b, 0xac, 0xef, 0xfd, 0xcf, 0x75, 0x34, 0x01, 0xa0, 0x5b, 0x50, 0x94, 0x5d, 0x38, 0xa1, 0xa4, - 0xe7, 0x52, 0x0a, 0x11, 0xca, 0x49, 0x40, 0xd5, 0x5f, 0xd3, 0x90, 0x55, 0x71, 0x99, 0xef, 0x59, - 0xc7, 0xa9, 0xf3, 0x6c, 0xba, 0x66, 0x5f, 0x7d, 0x58, 0xcd, 0xf4, 0xf9, 0x35, 0x39, 0x5a, 0x83, - 0xf4, 0x07, 0xd4, 0x60, 0x2a, 0xe7, 0xfa, 0xc9, 0x73, 0x9e, 0x79, 0xff, 0x9c, 0x67, 0x4f, 0x90, - 0x73, 0x64, 0xc1, 0x6a, 0x94, 0x68, 0x1a, 0x50, 0x41, 0x27, 0x17, 0x88, 0x2b, 0xc3, 0x37, 0x16, - 0xe7, 0x5a, 0x38, 0xeb, 0xd3, 0xc0, 0x8a, 0xf1, 0x2a, 0x3d, 0x76, 0x84, 0xbe, 0xf2, 0x9d, 0x06, - 0x30, 0xf5, 0xe2, 0x39, 0x0f, 0xe7, 0x76, 0x5b, 0x8e, 0xe9, 0xb6, 0xda, 0x8e, 0xd5, 0xda, 0x71, - 0x1f, 0xec, 0x74, 0xda, 0xe6, 0xb6, 0x75, 0xc7, 0x32, 0x9b, 0xa5, 0x05, 0x74, 0x06, 0x4e, 0x4d, - 0x2b, 0x1f, 0x99, 0x9d, 0x92, 0x86, 0xce, 0xc1, 0x99, 0x69, 0x61, 0x63, 0xab, 0xe3, 0x34, 0xac, - 0x9d, 0x52, 0x0a, 0x21, 0x28, 0x4e, 0x2b, 0x76, 0x5a, 0xa5, 0x34, 0xba, 0x00, 0xc6, 0x61, 0x99, - 0xfb, 0xd0, 0x72, 0xee, 0xba, 0xbb, 0xa6, 0xd3, 0x2a, 0xe9, 0x57, 0x7e, 0xd7, 0xa0, 0x78, 0xf8, - 0x15, 0x80, 0x2a, 0x70, 0xbe, 0x6d, 0xb7, 0xda, 0xad, 0x4e, 0xe3, 0xbe, 0xdb, 0x71, 0x1a, 0xce, - 0x83, 0xce, 0x4c, 0x4c, 0x55, 0x28, 0xcf, 0x02, 0x9a, 0x66, 0xbb, 0xd5, 0xb1, 0x1c, 0xb7, 0x6d, - 0xda, 0x56, 0xab, 0x59, 0xd2, 0xd0, 0x25, 0xb8, 0x38, 0x8b, 0xd9, 0x6d, 0x39, 0xd6, 0xce, 0x97, - 0x09, 0x24, 0x85, 0xd6, 0xe0, 0xec, 0x2c, 0xa4, 0xdd, 0xe8, 0x74, 0xcc, 0x66, 0x1c, 0xf4, 0xac, - 0xce, 0x36, 0xef, 0x99, 0xdb, 0x8e, 0xd9, 0x2c, 0xe9, 0xf3, 0x98, 0x77, 0x1a, 0xd6, 0x7d, 0xb3, - 0x59, 0xca, 0x6c, 0x99, 0x2f, 0xde, 0x94, 0xb5, 0x97, 0x6f, 0xca, 0xda, 0x3f, 0x6f, 0xca, 0xda, - 0xb3, 0xb7, 0xe5, 0x85, 0x97, 0x6f, 0xcb, 0x0b, 0x7f, 0xbe, 0x2d, 0x2f, 0x7c, 0x7d, 0xb5, 0x4b, - 0x45, 0x6f, 0xb8, 0x57, 0xdb, 0x67, 0xbe, 0x7a, 0x9b, 0xaa, 0xbf, 0xeb, 0xdc, 0xfb, 0xa6, 0xfe, - 0x54, 0xbe, 0xb7, 0xc5, 0x78, 0x40, 0x78, 0xf4, 0x98, 0xce, 0xca, 0x16, 0xbd, 0xf9, 0x5f, 0x00, - 0x00, 0x00, 0xff, 0xff, 0x31, 0x0a, 0x72, 0x23, 0x8d, 0x0b, 0x00, 0x00, + // 1252 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x56, 0xcf, 0x73, 0xd3, 0x46, + 0x14, 0x8e, 0x6c, 0xd9, 0x71, 0x9e, 0x63, 0x63, 0x96, 0x00, 0x4a, 0x00, 0x3b, 0x78, 0x3a, 0x4c, + 0xca, 0x0f, 0xbb, 0x81, 0xd2, 0x0b, 0xbd, 0xd8, 0xb1, 0x28, 0xca, 0xd0, 0xd8, 0x23, 0x8b, 0x30, + 0xf4, 0xa2, 0x51, 0xac, 0xc5, 0xd9, 0xa9, 0xa5, 0x75, 0xb5, 0x6b, 0x83, 0xff, 0x84, 0xde, 0x38, + 0x76, 0x7a, 0xea, 0xb1, 0xc7, 0x1e, 0x98, 0xde, 0x7b, 0xe3, 0xd0, 0xe9, 0x30, 0x5c, 0xda, 0x5e, + 0x68, 0x07, 0x0e, 0x9d, 0xe1, 0xaf, 0xe8, 0x68, 0xb5, 0x8a, 0x1d, 0xc5, 0x6d, 0x02, 0x17, 0x5b, + 0x7a, 0xef, 0xfb, 0xbe, 0x7d, 0xfb, 0x7e, 0xac, 0x16, 0xce, 0xf7, 0x28, 0xf3, 0x28, 0xab, 0xf7, + 0xe9, 0xb8, 0x3e, 0xde, 0x0c, 0xff, 0x6a, 0xc3, 0x80, 0x72, 0x8a, 0x0a, 0x91, 0xa3, 0x16, 0x5a, + 0xc6, 0x9b, 0x6b, 0x65, 0x89, 0xdb, 0x73, 0x18, 0xae, 0x8f, 0x37, 0xf7, 0x30, 0x77, 0x36, 0xeb, + 0x3d, 0x4a, 0xfc, 0x08, 0xbe, 0xb6, 0xd2, 0xa7, 0x7d, 0x2a, 0x1e, 0xeb, 0xe1, 0x93, 0xb4, 0x56, + 0xfa, 0x94, 0xf6, 0x07, 0xb8, 0x2e, 0xde, 0xf6, 0x46, 0x8f, 0xeb, 0x9c, 0x78, 0x98, 0x71, 0xc7, + 0x1b, 0x4a, 0xc0, 0x6a, 0x12, 0xe0, 0xf8, 0x13, 0xe9, 0x2a, 0x27, 0x5d, 0xee, 0x28, 0x70, 0x38, + 0xa1, 0xf1, 0x8a, 0xab, 0x51, 0x44, 0x76, 0xb4, 0xa8, 0x8c, 0x36, 0x72, 0x9d, 0x76, 0x3c, 0xe2, + 0xd3, 0xba, 0xf8, 0x8d, 0x4c, 0x55, 0x0a, 0xe8, 0x21, 0x26, 0xfd, 0x7d, 0x8e, 0xdd, 0x5d, 0xca, + 0x71, 0x7b, 0x18, 0x2a, 0xa1, 0x4d, 0xc8, 0x52, 0xf1, 0xa4, 0x29, 0xeb, 0xca, 0x46, 0xf1, 0xe6, + 0x6a, 0xed, 0xd0, 0xae, 0x6b, 0x53, 0xa8, 0x29, 0x81, 0xe8, 0x0a, 0x64, 0x9f, 0x08, 0x21, 0x2d, + 0xb5, 0xae, 0x6c, 0x2c, 0x35, 0x8b, 0xaf, 0x9e, 0xdf, 0x00, 0xc9, 0x6a, 0xe1, 0x9e, 0x29, 0xbd, + 0xd5, 0x1f, 0x14, 0x58, 0x6c, 0xe1, 0x21, 0x65, 0x84, 0xa3, 0x0a, 0xe4, 0x87, 0x01, 0x1d, 0x52, + 0xe6, 0x0c, 0x6c, 0xe2, 0x8a, 0xb5, 0x54, 0x13, 0x62, 0x93, 0xe1, 0xa2, 0xcf, 0x60, 0xc9, 0x8d, + 0xb0, 0x34, 0x90, 0xba, 0xda, 0xab, 0xe7, 0x37, 0x56, 0xa4, 0x6e, 0xc3, 0x75, 0x03, 0xcc, 0x58, + 0x97, 0x07, 0xc4, 0xef, 0x9b, 0x53, 0x28, 0xfa, 0x1c, 0xb2, 0x8e, 0x47, 0x47, 0x3e, 0xd7, 0xd2, + 0xeb, 0xe9, 0x8d, 0xfc, 0x34, 0xfe, 0xb0, 0x4c, 0x35, 0x59, 0xa6, 0xda, 0x16, 0x25, 0x7e, 0x73, + 0xe9, 0xc5, 0xeb, 0xca, 0xc2, 0x8f, 0xff, 0xfc, 0x74, 0x55, 0x31, 0x25, 0xa7, 0xfa, 0x4b, 0x06, + 0x72, 0x1d, 0x19, 0x04, 0x2a, 0x42, 0xea, 0x20, 0xb4, 0x14, 0x71, 0xd1, 0x27, 0x90, 0xf3, 0x30, + 0x63, 0x4e, 0x1f, 0x33, 0x2d, 0x25, 0xc4, 0x57, 0x6a, 0x51, 0x45, 0x6a, 0x71, 0x45, 0x6a, 0x0d, + 0x7f, 0x62, 0x1e, 0xa0, 0xd0, 0x6d, 0xc8, 0x32, 0xee, 0xf0, 0x11, 0xd3, 0xd2, 0x22, 0x99, 0x97, + 0x12, 0xc9, 0x8c, 0x97, 0xea, 0x0a, 0x90, 0x29, 0xc1, 0xe8, 0x1e, 0xa0, 0xc7, 0xc4, 0x77, 0x06, + 0x36, 0x77, 0x06, 0x83, 0x89, 0x1d, 0x60, 0x36, 0x1a, 0x70, 0x4d, 0x5d, 0x57, 0x36, 0xf2, 0x37, + 0xd7, 0x12, 0x12, 0x56, 0x08, 0x31, 0x05, 0xc2, 0x2c, 0x09, 0xd6, 0x8c, 0x05, 0x35, 0x20, 0xcf, + 0x46, 0x7b, 0x1e, 0xe1, 0x76, 0xd8, 0x66, 0x5a, 0x46, 0x4a, 0x24, 0xa3, 0xb6, 0xe2, 0x1e, 0x6c, + 0xaa, 0xcf, 0xfe, 0xaa, 0x28, 0x26, 0x44, 0xa4, 0xd0, 0x8c, 0xb6, 0xa1, 0x24, 0xb3, 0x6b, 0x63, + 0xdf, 0x8d, 0x74, 0xb2, 0x27, 0xd4, 0x29, 0x4a, 0xa6, 0xee, 0xbb, 0x42, 0xcb, 0x80, 0x02, 0xa7, + 0xdc, 0x19, 0xd8, 0xd2, 0xae, 0x2d, 0xbe, 0x47, 0x8d, 0x96, 0x05, 0x35, 0x6e, 0xa0, 0xfb, 0x70, + 0x7a, 0x4c, 0x39, 0xf1, 0xfb, 0x36, 0xe3, 0x4e, 0x20, 0xf7, 0x97, 0x3b, 0x61, 0x5c, 0xa7, 0x22, + 0x6a, 0x37, 0x64, 0x8a, 0xc0, 0xee, 0x81, 0x34, 0x4d, 0xf7, 0xb8, 0x74, 0x42, 0xad, 0x42, 0x44, + 0x8c, 0xb7, 0xb8, 0x16, 0x36, 0x09, 0x77, 0x5c, 0x87, 0x3b, 0x1a, 0x84, 0x6d, 0x6b, 0x1e, 0xbc, + 0xa3, 0x15, 0xc8, 0x70, 0xc2, 0x07, 0x58, 0xcb, 0x0b, 0x47, 0xf4, 0x82, 0x34, 0x58, 0x64, 0x23, + 0xcf, 0x73, 0x82, 0x89, 0xb6, 0x2c, 0xec, 0xf1, 0x2b, 0xfa, 0x14, 0x72, 0xd1, 0x44, 0xe0, 0x40, + 0x2b, 0x1c, 0x33, 0x02, 0x07, 0xc8, 0xea, 0xef, 0x0a, 0xe4, 0x67, 0x7b, 0xe0, 0x1a, 0x2c, 0x4d, + 0x30, 0xb3, 0x7b, 0x62, 0x28, 0x94, 0x23, 0x13, 0x6a, 0xf8, 0xdc, 0xcc, 0x4d, 0x30, 0xdb, 0x0a, + 0xfd, 0xe8, 0x16, 0x14, 0x9c, 0x3d, 0xc6, 0x1d, 0xe2, 0x4b, 0x42, 0x6a, 0x2e, 0x61, 0x59, 0x82, + 0x22, 0xd2, 0xc7, 0x90, 0xf3, 0xa9, 0xc4, 0xa7, 0xe7, 0xe2, 0x17, 0x7d, 0x1a, 0x41, 0xef, 0x00, + 0xf2, 0xa9, 0xfd, 0x84, 0xf0, 0x7d, 0x7b, 0x8c, 0x79, 0x4c, 0x52, 0xe7, 0x92, 0x4e, 0xf9, 0xf4, + 0x21, 0xe1, 0xfb, 0xbb, 0x98, 0x47, 0xe4, 0xea, 0xcf, 0x0a, 0xa8, 0xe1, 0xf9, 0x73, 0xfc, 0xe9, + 0x51, 0x83, 0xcc, 0x98, 0x72, 0x7c, 0xfc, 0xc9, 0x11, 0xc1, 0xd0, 0x1d, 0x58, 0x8c, 0x0e, 0x33, + 0xa6, 0xa9, 0xa2, 0x25, 0x2f, 0x27, 0xc6, 0xec, 0xe8, 0x49, 0x69, 0xc6, 0x8c, 0x43, 0x25, 0xcf, + 0x1c, 0x2e, 0xf9, 0xb6, 0x9a, 0x4b, 0x97, 0xd4, 0xea, 0x9f, 0x0a, 0x14, 0x64, 0xe3, 0x76, 0x9c, + 0xc0, 0xf1, 0x18, 0x7a, 0x04, 0x79, 0x8f, 0xf8, 0x07, 0x73, 0xa0, 0x1c, 0x37, 0x07, 0x97, 0xc2, + 0x39, 0x78, 0xf7, 0xba, 0x72, 0x76, 0x86, 0x75, 0x9d, 0x7a, 0x84, 0x63, 0x6f, 0xc8, 0x27, 0x26, + 0x78, 0xc4, 0x8f, 0x27, 0xc3, 0x03, 0xe4, 0x39, 0x4f, 0x63, 0x90, 0x3d, 0xc4, 0x01, 0xa1, 0xae, + 0x48, 0x44, 0xb8, 0x42, 0xb2, 0x9d, 0x5b, 0xf2, 0x13, 0xd2, 0xfc, 0xe8, 0xdd, 0xeb, 0xca, 0xc5, + 0xa3, 0xc4, 0xe9, 0x22, 0xdf, 0x85, 0xdd, 0x5e, 0xf2, 0x9c, 0xa7, 0xf1, 0x4e, 0x84, 0xbf, 0x6a, + 0xc1, 0xf2, 0xae, 0x98, 0x00, 0xb9, 0xb3, 0x16, 0xc8, 0x89, 0x88, 0x57, 0x56, 0x8e, 0x5b, 0x59, + 0x15, 0xca, 0xcb, 0x11, 0x4b, 0xaa, 0x7e, 0x1f, 0x37, 0xb1, 0x54, 0xbd, 0x02, 0xd9, 0x6f, 0x46, + 0x34, 0x18, 0x79, 0x73, 0x3a, 0x58, 0x7c, 0x63, 0x22, 0x2f, 0xba, 0x0e, 0x4b, 0x7c, 0x3f, 0xc0, + 0x6c, 0x9f, 0x0e, 0xdc, 0xff, 0xf8, 0x1c, 0x4d, 0x01, 0xe8, 0x36, 0x14, 0x45, 0x17, 0x4e, 0x29, + 0xe9, 0xb9, 0x94, 0x42, 0x88, 0xb2, 0x62, 0x50, 0xf5, 0x57, 0x15, 0xb2, 0x32, 0x2e, 0xfd, 0x3d, + 0xeb, 0x38, 0x73, 0x9e, 0xcd, 0xd6, 0xec, 0xcb, 0x0f, 0xab, 0x99, 0x3a, 0xbf, 0x26, 0x47, 0x6b, + 0x90, 0xfe, 0x80, 0x1a, 0xcc, 0xe4, 0x5c, 0x3d, 0x79, 0xce, 0x33, 0xef, 0x9f, 0xf3, 0xec, 0x09, + 0x72, 0x8e, 0x0c, 0x58, 0x0d, 0x13, 0x4d, 0x7c, 0xc2, 0xc9, 0xf4, 0x03, 0x62, 0x8b, 0xf0, 0xb5, + 0xc5, 0xb9, 0x0a, 0xe7, 0x3c, 0xe2, 0x1b, 0x11, 0x5e, 0xa6, 0xc7, 0x0c, 0xd1, 0xa8, 0x09, 0x67, + 0x0f, 0x4e, 0x8f, 0x9e, 0xe3, 0xf7, 0xf0, 0x40, 0xca, 0xe4, 0xe6, 0xca, 0x9c, 0x89, 0xc1, 0x5b, + 0x02, 0x1b, 0x69, 0x6c, 0xc3, 0x4a, 0x52, 0xc3, 0xc5, 0x8c, 0x8b, 0xaf, 0xc6, 0xff, 0x9d, 0x37, + 0xe8, 0xb0, 0x58, 0x0b, 0x33, 0x7e, 0xf5, 0x5b, 0x05, 0x60, 0xe6, 0x06, 0x76, 0x01, 0xce, 0xef, + 0xb6, 0x2d, 0xdd, 0x6e, 0x77, 0x2c, 0xa3, 0xbd, 0x63, 0x3f, 0xd8, 0xe9, 0x76, 0xf4, 0x2d, 0xe3, + 0xae, 0xa1, 0xb7, 0x4a, 0x0b, 0xe8, 0x0c, 0x9c, 0x9a, 0x75, 0x3e, 0xd2, 0xbb, 0x25, 0x05, 0x9d, + 0x87, 0x33, 0xb3, 0xc6, 0x46, 0xb3, 0x6b, 0x35, 0x8c, 0x9d, 0x52, 0x0a, 0x21, 0x28, 0xce, 0x3a, + 0x76, 0xda, 0xa5, 0x34, 0xba, 0x08, 0xda, 0x61, 0x9b, 0xfd, 0xd0, 0xb0, 0xee, 0xd9, 0xbb, 0xba, + 0xd5, 0x2e, 0xa9, 0x57, 0x7f, 0x53, 0xa0, 0x78, 0xf8, 0x56, 0x82, 0x2a, 0x70, 0xa1, 0x63, 0xb6, + 0x3b, 0xed, 0x6e, 0xe3, 0xbe, 0xdd, 0xb5, 0x1a, 0xd6, 0x83, 0x6e, 0x22, 0xa6, 0x2a, 0x94, 0x93, + 0x80, 0x96, 0xde, 0x69, 0x77, 0x0d, 0xcb, 0xee, 0xe8, 0xa6, 0xd1, 0x6e, 0x95, 0x14, 0x74, 0x19, + 0x2e, 0x25, 0x31, 0xbb, 0x6d, 0xcb, 0xd8, 0xf9, 0x22, 0x86, 0xa4, 0xd0, 0x1a, 0x9c, 0x4b, 0x42, + 0x3a, 0x8d, 0x6e, 0x57, 0x6f, 0x45, 0x41, 0x27, 0x7d, 0xa6, 0xbe, 0xad, 0x6f, 0x59, 0x7a, 0xab, + 0xa4, 0xce, 0x63, 0xde, 0x6d, 0x18, 0xf7, 0xf5, 0x56, 0x29, 0xd3, 0xd4, 0x5f, 0xbc, 0x29, 0x2b, + 0x2f, 0xdf, 0x94, 0x95, 0xbf, 0xdf, 0x94, 0x95, 0x67, 0x6f, 0xcb, 0x0b, 0x2f, 0xdf, 0x96, 0x17, + 0xfe, 0x78, 0x5b, 0x5e, 0xf8, 0xea, 0x5a, 0x9f, 0xf0, 0xfd, 0xd1, 0x5e, 0xad, 0x47, 0x3d, 0x79, + 0x57, 0x96, 0x7f, 0x37, 0x98, 0xfb, 0x75, 0xfd, 0xa9, 0xb8, 0xff, 0xf3, 0xc9, 0x10, 0xb3, 0xf0, + 0x72, 0x9f, 0x15, 0x23, 0x73, 0xeb, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x56, 0xd0, 0x44, 0x5e, + 0x1d, 0x0c, 0x00, 0x00, } func (m *WeightedVoteOption) Marshal() (dAtA []byte, err error) { @@ -1395,6 +1421,20 @@ func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if len(m.ProposalCancelDest) > 0 { + i -= len(m.ProposalCancelDest) + copy(dAtA[i:], m.ProposalCancelDest) + i = encodeVarintGov(dAtA, i, uint64(len(m.ProposalCancelDest))) + i-- + dAtA[i] = 0x4a + } + if len(m.ProposalCancelRatio) > 0 { + i -= len(m.ProposalCancelRatio) + copy(dAtA[i:], m.ProposalCancelRatio) + i = encodeVarintGov(dAtA, i, uint64(len(m.ProposalCancelRatio))) + i-- + dAtA[i] = 0x42 + } if len(m.MinInitialDepositRatio) > 0 { i -= len(m.MinInitialDepositRatio) copy(dAtA[i:], m.MinInitialDepositRatio) @@ -1712,6 +1752,14 @@ func (m *Params) Size() (n int) { if l > 0 { n += 1 + l + sovGov(uint64(l)) } + l = len(m.ProposalCancelRatio) + if l > 0 { + n += 1 + l + sovGov(uint64(l)) + } + l = len(m.ProposalCancelDest) + if l > 0 { + n += 1 + l + sovGov(uint64(l)) + } return n } @@ -3381,6 +3429,70 @@ func (m *Params) Unmarshal(dAtA []byte) error { } m.MinInitialDepositRatio = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposalCancelRatio", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGov + } + 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 ErrInvalidLengthGov + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGov + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ProposalCancelRatio = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposalCancelDest", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGov + } + 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 ErrInvalidLengthGov + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGov + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ProposalCancelDest = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipGov(dAtA[iNdEx:]) diff --git a/x/gov/types/v1/msgs.go b/x/gov/types/v1/msgs.go index f1b1667d59d..93d391644de 100644 --- a/x/gov/types/v1/msgs.go +++ b/x/gov/types/v1/msgs.go @@ -15,8 +15,8 @@ import ( ) var ( - _, _, _, _, _, _ sdk.Msg = &MsgSubmitProposal{}, &MsgDeposit{}, &MsgVote{}, &MsgVoteWeighted{}, &MsgExecLegacyContent{}, &MsgUpdateParams{} - _, _ codectypes.UnpackInterfacesMessage = &MsgSubmitProposal{}, &MsgExecLegacyContent{} + _, _, _, _, _, _, _ sdk.Msg = &MsgSubmitProposal{}, &MsgDeposit{}, &MsgVote{}, &MsgVoteWeighted{}, &MsgExecLegacyContent{}, &MsgUpdateParams{}, &MsgCancelProposal{} + _, _ codectypes.UnpackInterfacesMessage = &MsgSubmitProposal{}, &MsgExecLegacyContent{} ) // NewMsgSubmitProposal creates a new MsgSubmitProposal. @@ -309,3 +309,40 @@ func (msg MsgUpdateParams) GetSigners() []sdk.AccAddress { authority, _ := sdk.AccAddressFromBech32(msg.Authority) return []sdk.AccAddress{authority} } + +// NewMsgCancelProposal creates a new MsgCancelProposal instance +// +//nolint:interfacer +func NewMsgCancelProposal(proposalID uint64, proposer string) *MsgCancelProposal { + return &MsgCancelProposal{ + ProposalId: proposalID, + Proposer: proposer, + } +} + +// Route implements Msg +func (msg MsgCancelProposal) Route() string { return types.RouterKey } + +// Type implements Msg +func (msg MsgCancelProposal) Type() string { return sdk.MsgTypeURL(&msg) } + +// ValidateBasic implements Msg +func (msg MsgCancelProposal) ValidateBasic() error { + if _, err := sdk.AccAddressFromBech32(msg.Proposer); err != nil { + return sdkerrors.ErrInvalidAddress.Wrapf("invalid proposer address: %s", err) + } + + return nil +} + +// GetSignBytes implements Msg +func (msg MsgCancelProposal) GetSignBytes() []byte { + bz := codec.ModuleCdc.MustMarshalJSON(&msg) + return sdk.MustSortJSON(bz) +} + +// GetSigners implements Msg +func (msg MsgCancelProposal) GetSigners() []sdk.AccAddress { + proposer, _ := sdk.AccAddressFromBech32(msg.Proposer) + return []sdk.AccAddress{proposer} +} diff --git a/x/gov/types/v1/params.go b/x/gov/types/v1/params.go index 3e0bd635543..c15176b01ca 100644 --- a/x/gov/types/v1/params.go +++ b/x/gov/types/v1/params.go @@ -16,11 +16,13 @@ const ( // Default governance params var ( - DefaultMinDepositTokens = sdk.NewInt(10000000) - DefaultQuorum = sdk.NewDecWithPrec(334, 3) - DefaultThreshold = sdk.NewDecWithPrec(5, 1) - DefaultVetoThreshold = sdk.NewDecWithPrec(334, 3) - DefaultMinInitialDepositRatio = sdk.ZeroDec() + DefaultMinDepositTokens = sdk.NewInt(10000000) + DefaultQuorum = sdk.NewDecWithPrec(334, 3) + DefaultThreshold = sdk.NewDecWithPrec(5, 1) + DefaultVetoThreshold = sdk.NewDecWithPrec(334, 3) + DefaultMinInitialDepositRatio = sdk.ZeroDec() + DefaultProposalCancelRatio = sdk.MustNewDecFromStr("0.5") + DefaultProposalCancelDestAddress = "" ) // Deprecated: NewDepositParams creates a new DepositParams object @@ -50,7 +52,7 @@ func NewVotingParams(votingPeriod *time.Duration) VotingParams { // NewParams creates a new Params instance with given values. func NewParams( minDeposit sdk.Coins, maxDepositPeriod time.Duration, votingPeriod time.Duration, - quorum string, threshold string, vetoThreshold string, minInitialDepositRatio string, + quorum, threshold, vetoThreshold, minInitialDepositRatio, proposalCancelRatio, proposalCancelDest string, ) Params { return Params{ MinDeposit: minDeposit, @@ -60,6 +62,8 @@ func NewParams( Threshold: threshold, VetoThreshold: vetoThreshold, MinInitialDepositRatio: minInitialDepositRatio, + ProposalCancelRatio: proposalCancelRatio, + ProposalCancelDest: proposalCancelDest, } } @@ -73,6 +77,8 @@ func DefaultParams() Params { DefaultThreshold.String(), DefaultVetoThreshold.String(), DefaultMinInitialDepositRatio.String(), + DefaultProposalCancelRatio.String(), + DefaultProposalCancelDestAddress, ) } @@ -131,5 +137,34 @@ func (p Params) ValidateBasic() error { return fmt.Errorf("voting period must be positive: %s", p.VotingPeriod) } + minInitialDepositRatio, err := sdk.NewDecFromStr(p.MinInitialDepositRatio) + if err != nil { + return fmt.Errorf("invalid mininum initial deposit ratio of proposal: %w", err) + } + if minInitialDepositRatio.IsNegative() { + return fmt.Errorf("mininum initial deposit ratio of proposal must be positive: %s", minInitialDepositRatio) + } + if minInitialDepositRatio.GT(math.LegacyOneDec()) { + return fmt.Errorf("mininum initial deposit ratio of proposal is too large: %s", minInitialDepositRatio) + } + + proposalCancelRate, err := sdk.NewDecFromStr(p.ProposalCancelRatio) + if err != nil { + return fmt.Errorf("invalid burn rate of cancel proposal: %w", err) + } + if proposalCancelRate.IsNegative() { + return fmt.Errorf("burn rate of cancel proposal must be positive: %s", proposalCancelRate) + } + if proposalCancelRate.GT(math.LegacyOneDec()) { + return fmt.Errorf("burn rate of cancel proposal is too large: %s", proposalCancelRate) + } + + if len(p.ProposalCancelDest) != 0 { + _, err := sdk.AccAddressFromBech32(p.ProposalCancelDest) + if err != nil { + return fmt.Errorf("deposits destination address is invalid: %s", p.ProposalCancelDest) + } + } + return nil } diff --git a/x/gov/types/v1/tx.pb.go b/x/gov/types/v1/tx.pb.go index 4a27b2077ef..a7dfdb3838e 100644 --- a/x/gov/types/v1/tx.pb.go +++ b/x/gov/types/v1/tx.pb.go @@ -14,18 +14,22 @@ import ( _ "github.com/cosmos/gogoproto/gogoproto" grpc1 "github.com/cosmos/gogoproto/grpc" proto "github.com/cosmos/gogoproto/proto" + github_com_cosmos_gogoproto_types "github.com/cosmos/gogoproto/types" grpc "google.golang.org/grpc" codes "google.golang.org/grpc/codes" status "google.golang.org/grpc/status" + _ "google.golang.org/protobuf/types/known/timestamppb" io "io" math "math" math_bits "math/bits" + time "time" ) // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal var _ = fmt.Errorf var _ = math.Inf +var _ = time.Kitchen // This is a compile-time assertion to ensure that this generated file // is compatible with the proto package it is being compiled against. @@ -688,6 +692,127 @@ func (m *MsgUpdateParamsResponse) XXX_DiscardUnknown() { var xxx_messageInfo_MsgUpdateParamsResponse proto.InternalMessageInfo +// MsgCancelProposal is the Msg/CancelProposal request type. +// +// Since: cosmos-sdk 0.48 +type MsgCancelProposal struct { + ProposalId uint64 `protobuf:"varint,1,opt,name=proposal_id,json=proposalId,proto3" json:"proposal_id"` + Proposer string `protobuf:"bytes,2,opt,name=proposer,proto3" json:"proposer,omitempty"` +} + +func (m *MsgCancelProposal) Reset() { *m = MsgCancelProposal{} } +func (m *MsgCancelProposal) String() string { return proto.CompactTextString(m) } +func (*MsgCancelProposal) ProtoMessage() {} +func (*MsgCancelProposal) Descriptor() ([]byte, []int) { + return fileDescriptor_9ff8f4a63b6fc9a9, []int{12} +} +func (m *MsgCancelProposal) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgCancelProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgCancelProposal.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 *MsgCancelProposal) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgCancelProposal.Merge(m, src) +} +func (m *MsgCancelProposal) XXX_Size() int { + return m.Size() +} +func (m *MsgCancelProposal) XXX_DiscardUnknown() { + xxx_messageInfo_MsgCancelProposal.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgCancelProposal proto.InternalMessageInfo + +func (m *MsgCancelProposal) GetProposalId() uint64 { + if m != nil { + return m.ProposalId + } + return 0 +} + +func (m *MsgCancelProposal) GetProposer() string { + if m != nil { + return m.Proposer + } + return "" +} + +// MsgCancelProposalResponse defines the response structure for executing a +// MsgCancelProposal message. +// +// Since: cosmos-sdk 0.48 +type MsgCancelProposalResponse struct { + ProposalId uint64 `protobuf:"varint,1,opt,name=proposal_id,json=proposalId,proto3" json:"proposal_id"` + // canceled_time is the time when proposal is canceled. + CanceledTime time.Time `protobuf:"bytes,2,opt,name=canceled_time,json=canceledTime,proto3,stdtime" json:"canceled_time"` + // canceled_height defines the block height at which the proposal is canceled. + CanceledHeight uint64 `protobuf:"varint,3,opt,name=canceled_height,json=canceledHeight,proto3" json:"canceled_height,omitempty"` +} + +func (m *MsgCancelProposalResponse) Reset() { *m = MsgCancelProposalResponse{} } +func (m *MsgCancelProposalResponse) String() string { return proto.CompactTextString(m) } +func (*MsgCancelProposalResponse) ProtoMessage() {} +func (*MsgCancelProposalResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_9ff8f4a63b6fc9a9, []int{13} +} +func (m *MsgCancelProposalResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgCancelProposalResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgCancelProposalResponse.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 *MsgCancelProposalResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgCancelProposalResponse.Merge(m, src) +} +func (m *MsgCancelProposalResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgCancelProposalResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgCancelProposalResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgCancelProposalResponse proto.InternalMessageInfo + +func (m *MsgCancelProposalResponse) GetProposalId() uint64 { + if m != nil { + return m.ProposalId + } + return 0 +} + +func (m *MsgCancelProposalResponse) GetCanceledTime() time.Time { + if m != nil { + return m.CanceledTime + } + return time.Time{} +} + +func (m *MsgCancelProposalResponse) GetCanceledHeight() uint64 { + if m != nil { + return m.CanceledHeight + } + return 0 +} + func init() { proto.RegisterType((*MsgSubmitProposal)(nil), "cosmos.gov.v1.MsgSubmitProposal") proto.RegisterType((*MsgSubmitProposalResponse)(nil), "cosmos.gov.v1.MsgSubmitProposalResponse") @@ -701,69 +826,79 @@ func init() { proto.RegisterType((*MsgDepositResponse)(nil), "cosmos.gov.v1.MsgDepositResponse") proto.RegisterType((*MsgUpdateParams)(nil), "cosmos.gov.v1.MsgUpdateParams") proto.RegisterType((*MsgUpdateParamsResponse)(nil), "cosmos.gov.v1.MsgUpdateParamsResponse") + proto.RegisterType((*MsgCancelProposal)(nil), "cosmos.gov.v1.MsgCancelProposal") + proto.RegisterType((*MsgCancelProposalResponse)(nil), "cosmos.gov.v1.MsgCancelProposalResponse") } func init() { proto.RegisterFile("cosmos/gov/v1/tx.proto", fileDescriptor_9ff8f4a63b6fc9a9) } var fileDescriptor_9ff8f4a63b6fc9a9 = []byte{ - // 908 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x56, 0xcf, 0x6f, 0x1b, 0x45, - 0x14, 0xce, 0xe6, 0x87, 0xdd, 0xbc, 0x40, 0xaa, 0x8c, 0xdc, 0x76, 0xbd, 0x2a, 0x9b, 0x74, 0x8b, - 0x50, 0x94, 0x90, 0x5d, 0x1c, 0x68, 0x85, 0x4c, 0x85, 0x54, 0x97, 0x0a, 0x21, 0x61, 0xa8, 0x5c, - 0x51, 0x24, 0x84, 0x14, 0x8d, 0xbd, 0xc3, 0x64, 0x45, 0x76, 0x67, 0xb5, 0x33, 0xb6, 0xe2, 0x1b, - 0xe2, 0xd8, 0x13, 0x7f, 0x06, 0xc7, 0x1c, 0x7a, 0xeb, 0x3f, 0x50, 0x38, 0x55, 0x9c, 0x38, 0x55, - 0x28, 0x11, 0x44, 0xe2, 0x9f, 0x00, 0xcd, 0x8f, 0x5d, 0xff, 0x58, 0xc7, 0xa9, 0x38, 0x70, 0xb1, - 0x76, 0xbe, 0xf7, 0xbd, 0x37, 0xef, 0xfb, 0xf6, 0xcd, 0xac, 0xe1, 0x7a, 0x8f, 0xf1, 0x98, 0xf1, - 0x80, 0xb2, 0x41, 0x30, 0x68, 0x04, 0xe2, 0xd8, 0x4f, 0x33, 0x26, 0x18, 0x7a, 0x53, 0xe3, 0x3e, - 0x65, 0x03, 0x7f, 0xd0, 0x70, 0x5c, 0x43, 0xeb, 0x62, 0x4e, 0x82, 0x41, 0xa3, 0x4b, 0x04, 0x6e, - 0x04, 0x3d, 0x16, 0x25, 0x9a, 0xee, 0xdc, 0x98, 0x2c, 0x23, 0xb3, 0x74, 0xa0, 0x46, 0x19, 0x65, - 0xea, 0x31, 0x90, 0x4f, 0x06, 0xad, 0x6b, 0xfa, 0x81, 0x0e, 0x98, 0xad, 0x4c, 0x88, 0x32, 0x46, - 0x8f, 0x48, 0xa0, 0x56, 0xdd, 0xfe, 0x77, 0x01, 0x4e, 0x86, 0x53, 0x9b, 0xc4, 0x9c, 0xca, 0x4d, - 0x62, 0x4e, 0x4d, 0x60, 0x03, 0xc7, 0x51, 0xc2, 0x02, 0xf5, 0xab, 0x21, 0xef, 0x97, 0x45, 0xd8, - 0x68, 0x73, 0xfa, 0xb8, 0xdf, 0x8d, 0x23, 0xf1, 0x28, 0x63, 0x29, 0xe3, 0xf8, 0x08, 0xbd, 0x07, - 0x57, 0x62, 0xc2, 0x39, 0xa6, 0x84, 0xdb, 0xd6, 0xd6, 0xd2, 0xf6, 0xda, 0x7e, 0xcd, 0xd7, 0xfb, - 0xf9, 0xf9, 0x7e, 0xfe, 0xfd, 0x64, 0xd8, 0x29, 0x58, 0xa8, 0x0d, 0x57, 0xa3, 0x24, 0x12, 0x11, - 0x3e, 0x3a, 0x08, 0x49, 0xca, 0x78, 0x24, 0xec, 0x45, 0x95, 0x58, 0xf7, 0x4d, 0xdb, 0xd2, 0x12, - 0xdf, 0x58, 0xe2, 0x3f, 0x60, 0x51, 0xd2, 0x5a, 0x7d, 0xf1, 0x6a, 0x73, 0xe1, 0xe7, 0xf3, 0x93, - 0x1d, 0xab, 0xb3, 0x6e, 0x92, 0x3f, 0xd1, 0xb9, 0xe8, 0x03, 0xb8, 0x92, 0xaa, 0x66, 0x48, 0x66, - 0x2f, 0x6d, 0x59, 0xdb, 0xab, 0x2d, 0xfb, 0xb7, 0x67, 0x7b, 0x35, 0x53, 0xea, 0x7e, 0x18, 0x66, - 0x84, 0xf3, 0xc7, 0x22, 0x8b, 0x12, 0xda, 0x29, 0x98, 0xc8, 0x91, 0x6d, 0x0b, 0x1c, 0x62, 0x81, - 0xed, 0x65, 0x99, 0xd5, 0x29, 0xd6, 0xa8, 0x06, 0x2b, 0x22, 0x12, 0x47, 0xc4, 0x5e, 0x51, 0x01, - 0xbd, 0x40, 0x36, 0x54, 0x79, 0x3f, 0x8e, 0x71, 0x36, 0xb4, 0x2b, 0x0a, 0xcf, 0x97, 0xcd, 0xc6, - 0x8f, 0xe7, 0x27, 0x3b, 0x45, 0xe9, 0xa7, 0xe7, 0x27, 0x3b, 0x9b, 0x7a, 0xf7, 0x3d, 0x1e, 0x7e, - 0x2f, 0x6d, 0x2d, 0xb9, 0xe6, 0xdd, 0x83, 0x7a, 0x09, 0xec, 0x10, 0x9e, 0xb2, 0x84, 0x13, 0xb4, - 0x09, 0x6b, 0xa9, 0xc1, 0x0e, 0xa2, 0xd0, 0xb6, 0xb6, 0xac, 0xed, 0xe5, 0x0e, 0xe4, 0xd0, 0x67, - 0xa1, 0xf7, 0xdc, 0x82, 0x5a, 0x9b, 0xd3, 0x87, 0xc7, 0xa4, 0xf7, 0x39, 0xa1, 0xb8, 0x37, 0x7c, - 0xc0, 0x12, 0x41, 0x12, 0x81, 0xbe, 0x80, 0x6a, 0x4f, 0x3f, 0xaa, 0xac, 0x0b, 0xde, 0x45, 0xcb, - 0xfd, 0xf5, 0xd9, 0x9e, 0x33, 0x31, 0x8d, 0xb9, 0xd5, 0x2a, 0xb7, 0x93, 0x17, 0x41, 0x37, 0x61, - 0x15, 0xf7, 0xc5, 0x21, 0xcb, 0x22, 0x31, 0xb4, 0x17, 0x95, 0xea, 0x11, 0xd0, 0xbc, 0x23, 0x75, - 0x8f, 0xd6, 0x52, 0xb8, 0x57, 0x12, 0x5e, 0x6a, 0xd2, 0x73, 0xe1, 0xe6, 0x2c, 0x3c, 0x97, 0xef, - 0xfd, 0x69, 0x41, 0xb5, 0xcd, 0xe9, 0x13, 0x26, 0x08, 0xba, 0x33, 0xc3, 0x8a, 0x56, 0xed, 0xef, - 0x57, 0x9b, 0xe3, 0xb0, 0x9e, 0x8b, 0x31, 0x83, 0x90, 0x0f, 0x2b, 0x03, 0x26, 0x48, 0xa6, 0x7b, - 0x9e, 0x33, 0x10, 0x9a, 0x86, 0x1a, 0x50, 0x61, 0xa9, 0x88, 0x58, 0xa2, 0x26, 0x68, 0x7d, 0x34, - 0x89, 0xda, 0x1d, 0x5f, 0xf6, 0xf2, 0xa5, 0x22, 0x74, 0x0c, 0x71, 0xde, 0x00, 0x35, 0xdf, 0x96, - 0xc6, 0xe8, 0xd2, 0xd2, 0x94, 0x6b, 0x25, 0x53, 0x64, 0x3d, 0x6f, 0x03, 0xae, 0x9a, 0xc7, 0x42, - 0xfa, 0x3f, 0x56, 0x81, 0x7d, 0x4d, 0x22, 0x7a, 0x28, 0x48, 0xf8, 0x7f, 0x59, 0xf0, 0x11, 0x54, - 0xb5, 0x32, 0x6e, 0x2f, 0xa9, 0xd3, 0x78, 0x6b, 0xca, 0x83, 0xbc, 0xa1, 0x31, 0x2f, 0xf2, 0x8c, - 0xb9, 0x66, 0xbc, 0x3b, 0x69, 0xc6, 0x5b, 0x33, 0xcd, 0xc8, 0x8b, 0x7b, 0x75, 0xb8, 0x31, 0x05, - 0x15, 0xe6, 0xfc, 0x65, 0x01, 0xb4, 0x39, 0xcd, 0xcf, 0xfd, 0x7f, 0xf4, 0xe5, 0x2e, 0xac, 0x9a, - 0x5b, 0x87, 0x5d, 0xee, 0xcd, 0x88, 0x8a, 0xee, 0x41, 0x05, 0xc7, 0xac, 0x9f, 0x08, 0x63, 0xcf, - 0xeb, 0x5d, 0x56, 0x26, 0xa7, 0xb9, 0xab, 0x8e, 0x4a, 0x51, 0x4d, 0x1a, 0x61, 0x97, 0x8c, 0x30, - 0xca, 0xbc, 0x1a, 0xa0, 0xd1, 0xaa, 0x90, 0xff, 0x5c, 0xcf, 0xc6, 0x57, 0x69, 0x88, 0x05, 0x79, - 0x84, 0x33, 0x1c, 0x73, 0x29, 0x66, 0x74, 0x3e, 0xad, 0xcb, 0xc4, 0x14, 0x54, 0xf4, 0x21, 0x54, - 0x52, 0x55, 0x41, 0x39, 0xb0, 0xb6, 0x7f, 0x6d, 0xea, 0x5d, 0xeb, 0xf2, 0x13, 0x42, 0x34, 0xbf, - 0x79, 0xb7, 0x7c, 0xe6, 0x6f, 0x8f, 0x09, 0x39, 0xce, 0x3f, 0x57, 0x53, 0x9d, 0x9a, 0xf7, 0x3a, - 0x0e, 0xe5, 0xc2, 0xf6, 0x9f, 0x2e, 0xc3, 0x52, 0x9b, 0x53, 0xf4, 0x2d, 0xac, 0x4f, 0x7d, 0x5b, - 0xb6, 0xa6, 0xda, 0x2a, 0x5d, 0x99, 0xce, 0xf6, 0x65, 0x8c, 0xe2, 0x52, 0x25, 0xb0, 0x51, 0xbe, - 0x2f, 0x6f, 0x97, 0xd3, 0x4b, 0x24, 0x67, 0xf7, 0x35, 0x48, 0xc5, 0x36, 0x1f, 0xc3, 0xb2, 0xba, - 0xb8, 0xae, 0x97, 0x93, 0x24, 0xee, 0xb8, 0xb3, 0xf1, 0x22, 0xff, 0x09, 0xbc, 0x31, 0x71, 0xfa, - 0x2f, 0xe0, 0xe7, 0x71, 0xe7, 0x9d, 0xf9, 0xf1, 0xa2, 0xee, 0xa7, 0x50, 0xcd, 0x0f, 0x4e, 0xbd, - 0x9c, 0x62, 0x42, 0xce, 0xad, 0x0b, 0x43, 0xe3, 0x0d, 0x4e, 0x8c, 0xe0, 0x8c, 0x06, 0xc7, 0xe3, - 0xb3, 0x1a, 0x9c, 0x35, 0x05, 0xce, 0xca, 0x0f, 0x72, 0xce, 0x5a, 0x0f, 0x5f, 0x9c, 0xba, 0xd6, - 0xcb, 0x53, 0xd7, 0xfa, 0xe3, 0xd4, 0xb5, 0x7e, 0x3a, 0x73, 0x17, 0x5e, 0x9e, 0xb9, 0x0b, 0xbf, - 0x9f, 0xb9, 0x0b, 0xdf, 0xec, 0xd2, 0x48, 0x1c, 0xf6, 0xbb, 0x7e, 0x8f, 0xc5, 0xe6, 0xef, 0x4d, - 0x50, 0x1a, 0x3c, 0x31, 0x4c, 0x09, 0x97, 0x7f, 0xa6, 0x2a, 0xea, 0x7b, 0xf7, 0xfe, 0xbf, 0x01, - 0x00, 0x00, 0xff, 0xff, 0xc2, 0x00, 0x8f, 0x53, 0x8c, 0x09, 0x00, 0x00, + // 1027 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x56, 0xcd, 0x6f, 0x1b, 0x45, + 0x14, 0xcf, 0x26, 0x8e, 0x9d, 0x4c, 0x9a, 0x44, 0x59, 0xb9, 0xed, 0x7a, 0x55, 0xd6, 0xe9, 0x16, + 0x41, 0x94, 0x90, 0x5d, 0x1c, 0x68, 0x85, 0x4c, 0x85, 0x54, 0x87, 0x0a, 0x2a, 0x61, 0xa8, 0xb6, + 0x50, 0x24, 0x84, 0x14, 0x8d, 0xbd, 0xc3, 0x66, 0x85, 0x77, 0x67, 0xe5, 0x19, 0x5b, 0xf1, 0x0d, + 0x71, 0xec, 0xa9, 0x7f, 0x06, 0xc7, 0x1c, 0x7a, 0xeb, 0x89, 0x5b, 0xe1, 0x54, 0x71, 0xe2, 0x14, + 0x50, 0x22, 0x08, 0xe2, 0x9f, 0x00, 0xcd, 0xc7, 0xae, 0xf7, 0x2b, 0x1f, 0x70, 0xe8, 0xc5, 0xda, + 0x79, 0xef, 0xf7, 0xde, 0xbc, 0xf7, 0x7b, 0xf3, 0xde, 0x33, 0xb8, 0xd6, 0xc7, 0x24, 0xc0, 0xc4, + 0xf6, 0xf0, 0xd8, 0x1e, 0xb7, 0x6c, 0x7a, 0x60, 0x45, 0x43, 0x4c, 0xb1, 0xba, 0x2c, 0xe4, 0x96, + 0x87, 0xc7, 0xd6, 0xb8, 0xa5, 0x1b, 0x12, 0xd6, 0x83, 0x04, 0xd9, 0xe3, 0x56, 0x0f, 0x51, 0xd8, + 0xb2, 0xfb, 0xd8, 0x0f, 0x05, 0x5c, 0xbf, 0x9e, 0x75, 0xc3, 0xac, 0x84, 0xa2, 0xee, 0x61, 0x0f, + 0xf3, 0x4f, 0x9b, 0x7d, 0x49, 0x69, 0x43, 0xc0, 0xf7, 0x84, 0x42, 0x5e, 0x25, 0x55, 0x1e, 0xc6, + 0xde, 0x00, 0xd9, 0xfc, 0xd4, 0x1b, 0x7d, 0x63, 0xc3, 0x70, 0x92, 0xbb, 0x24, 0x20, 0x1e, 0xbb, + 0x24, 0x20, 0x9e, 0x54, 0xac, 0xc1, 0xc0, 0x0f, 0xb1, 0xcd, 0x7f, 0xa5, 0xa8, 0x99, 0x77, 0x43, + 0xfd, 0x00, 0x11, 0x0a, 0x83, 0x48, 0x00, 0xcc, 0x9f, 0x66, 0xc1, 0x5a, 0x97, 0x78, 0x8f, 0x46, + 0xbd, 0xc0, 0xa7, 0x0f, 0x87, 0x38, 0xc2, 0x04, 0x0e, 0xd4, 0xb7, 0xc1, 0x42, 0x80, 0x08, 0x81, + 0x1e, 0x22, 0x9a, 0xb2, 0x3e, 0xb7, 0xb1, 0xb4, 0x53, 0xb7, 0x84, 0x27, 0x2b, 0xf6, 0x64, 0xdd, + 0x0b, 0x27, 0x4e, 0x82, 0x52, 0xbb, 0x60, 0xd5, 0x0f, 0x7d, 0xea, 0xc3, 0xc1, 0x9e, 0x8b, 0x22, + 0x4c, 0x7c, 0xaa, 0xcd, 0x72, 0xc3, 0x86, 0x25, 0xf3, 0x62, 0x9c, 0x59, 0x92, 0x33, 0x6b, 0x17, + 0xfb, 0x61, 0x67, 0xf1, 0xc5, 0x51, 0x73, 0xe6, 0x87, 0xd3, 0xc3, 0x4d, 0xc5, 0x59, 0x91, 0xc6, + 0x1f, 0x0a, 0x5b, 0xf5, 0x5d, 0xb0, 0x10, 0xf1, 0x60, 0xd0, 0x50, 0x9b, 0x5b, 0x57, 0x36, 0x16, + 0x3b, 0xda, 0x2f, 0xcf, 0xb6, 0xeb, 0xd2, 0xd5, 0x3d, 0xd7, 0x1d, 0x22, 0x42, 0x1e, 0xd1, 0xa1, + 0x1f, 0x7a, 0x4e, 0x82, 0x54, 0x75, 0x16, 0x36, 0x85, 0x2e, 0xa4, 0x50, 0xab, 0x30, 0x2b, 0x27, + 0x39, 0xab, 0x75, 0x30, 0x4f, 0x7d, 0x3a, 0x40, 0xda, 0x3c, 0x57, 0x88, 0x83, 0xaa, 0x81, 0x1a, + 0x19, 0x05, 0x01, 0x1c, 0x4e, 0xb4, 0x2a, 0x97, 0xc7, 0xc7, 0x76, 0xeb, 0xfb, 0xd3, 0xc3, 0xcd, + 0xc4, 0xf5, 0x93, 0xd3, 0xc3, 0xcd, 0xa6, 0xb8, 0x7d, 0x9b, 0xb8, 0xdf, 0x32, 0xde, 0x0b, 0xac, + 0x99, 0x77, 0x41, 0xa3, 0x20, 0x74, 0x10, 0x89, 0x70, 0x48, 0x90, 0xda, 0x04, 0x4b, 0x91, 0x94, + 0xed, 0xf9, 0xae, 0xa6, 0xac, 0x2b, 0x1b, 0x15, 0x07, 0xc4, 0xa2, 0x07, 0xae, 0xf9, 0x5c, 0x01, + 0xf5, 0x2e, 0xf1, 0xee, 0x1f, 0xa0, 0xfe, 0x27, 0xc8, 0x83, 0xfd, 0xc9, 0x2e, 0x0e, 0x29, 0x0a, + 0xa9, 0xfa, 0x29, 0xa8, 0xf5, 0xc5, 0x27, 0xb7, 0x3a, 0xa3, 0x16, 0x1d, 0xe3, 0xe7, 0x67, 0xdb, + 0x7a, 0xe6, 0xb9, 0xc6, 0x54, 0x73, 0x5b, 0x27, 0x76, 0xa2, 0xde, 0x00, 0x8b, 0x70, 0x44, 0xf7, + 0xf1, 0xd0, 0xa7, 0x13, 0x6d, 0x96, 0x67, 0x3d, 0x15, 0xb4, 0x6f, 0xb3, 0xbc, 0xa7, 0x67, 0x96, + 0xb8, 0x59, 0x48, 0xbc, 0x10, 0xa4, 0x69, 0x80, 0x1b, 0x65, 0xf2, 0x38, 0x7d, 0xf3, 0x0f, 0x05, + 0xd4, 0xba, 0xc4, 0x7b, 0x8c, 0x29, 0x52, 0x6f, 0x97, 0x50, 0xd1, 0xa9, 0xff, 0x7d, 0xd4, 0x4c, + 0x8b, 0xc5, 0xbb, 0x48, 0x11, 0xa4, 0x5a, 0x60, 0x7e, 0x8c, 0x29, 0x1a, 0x8a, 0x98, 0xcf, 0x79, + 0x10, 0x02, 0xa6, 0xb6, 0x40, 0x15, 0x47, 0xd4, 0xc7, 0x21, 0x7f, 0x41, 0x2b, 0xd3, 0x97, 0x28, + 0xd8, 0xb1, 0x58, 0x2c, 0x9f, 0x71, 0x80, 0x23, 0x81, 0xe7, 0x3d, 0xa0, 0xf6, 0xeb, 0x8c, 0x18, + 0xe1, 0x9a, 0x91, 0x72, 0xb5, 0x40, 0x0a, 0xf3, 0x67, 0xae, 0x81, 0x55, 0xf9, 0x99, 0xa4, 0xfe, + 0x8f, 0x92, 0xc8, 0xbe, 0x44, 0xbe, 0xb7, 0x4f, 0x91, 0xfb, 0xaa, 0x28, 0x78, 0x1f, 0xd4, 0x44, + 0x66, 0x44, 0x9b, 0xe3, 0xdd, 0x78, 0x33, 0xc7, 0x41, 0x1c, 0x50, 0x8a, 0x8b, 0xd8, 0xe2, 0x5c, + 0x32, 0xde, 0xca, 0x92, 0xf1, 0x5a, 0x29, 0x19, 0xb1, 0x73, 0xb3, 0x01, 0xae, 0xe7, 0x44, 0x09, + 0x39, 0x7f, 0x2a, 0x00, 0x74, 0x89, 0x17, 0xf7, 0xfd, 0xff, 0xe4, 0xe5, 0x0e, 0x58, 0x94, 0x53, + 0x07, 0x5f, 0xcc, 0xcd, 0x14, 0xaa, 0xde, 0x05, 0x55, 0x18, 0xe0, 0x51, 0x48, 0x25, 0x3d, 0x97, + 0x1b, 0x56, 0xd2, 0xa6, 0xbd, 0xc5, 0x5b, 0x25, 0xf1, 0xc6, 0x88, 0xd0, 0x0a, 0x44, 0xc8, 0xcc, + 0xcc, 0x3a, 0x50, 0xa7, 0xa7, 0x24, 0xfd, 0xe7, 0xe2, 0x6d, 0x7c, 0x11, 0xb9, 0x90, 0xa2, 0x87, + 0x70, 0x08, 0x03, 0xc2, 0x92, 0x99, 0xf6, 0xa7, 0x72, 0x51, 0x32, 0x09, 0x54, 0x7d, 0x0f, 0x54, + 0x23, 0xee, 0x81, 0x33, 0xb0, 0xb4, 0x73, 0x35, 0x57, 0x6b, 0xe1, 0x3e, 0x93, 0x88, 0xc0, 0xb7, + 0xef, 0x14, 0x7b, 0xfe, 0x56, 0x2a, 0x91, 0x83, 0x78, 0x9f, 0xe5, 0x22, 0x95, 0x75, 0x4d, 0x8b, + 0x92, 0xc4, 0x9e, 0x28, 0x7c, 0xaf, 0xec, 0xc2, 0xb0, 0x8f, 0x06, 0xa9, 0xbd, 0x52, 0x52, 0xde, + 0xd5, 0x5c, 0x79, 0x33, 0x95, 0x4d, 0x2f, 0x82, 0xd9, 0xcb, 0x2e, 0x82, 0xf6, 0x72, 0x66, 0x78, + 0x9b, 0x3f, 0x2a, 0x7c, 0x32, 0x67, 0x83, 0x49, 0x26, 0xf3, 0x7f, 0x0f, 0xea, 0x01, 0x58, 0xee, + 0x73, 0x5f, 0xc8, 0xdd, 0x63, 0x0b, 0x55, 0x12, 0xae, 0x17, 0xe6, 0xf2, 0xe7, 0xf1, 0xb6, 0xed, + 0x2c, 0x30, 0xd6, 0x9f, 0xfe, 0xd6, 0x54, 0x9c, 0x2b, 0xb1, 0x29, 0x53, 0xaa, 0x6f, 0x82, 0xd5, + 0xc4, 0xd5, 0x3e, 0x6f, 0x0e, 0x3e, 0xad, 0x2a, 0xce, 0x4a, 0x2c, 0xfe, 0x98, 0x4b, 0x77, 0xfe, + 0xaa, 0x80, 0xb9, 0x2e, 0xf1, 0xd4, 0xaf, 0xc1, 0x4a, 0x6e, 0x59, 0xaf, 0xe7, 0xea, 0x5c, 0xd8, + 0x41, 0xfa, 0xc6, 0x45, 0x88, 0x84, 0x0b, 0x04, 0xd6, 0x8a, 0x0b, 0xe8, 0x56, 0xd1, 0xbc, 0x00, + 0xd2, 0xb7, 0x2e, 0x01, 0x4a, 0xae, 0xf9, 0x00, 0x54, 0xf8, 0x26, 0xb8, 0x56, 0x34, 0x62, 0x72, + 0xdd, 0x28, 0x97, 0x27, 0xf6, 0x8f, 0xc1, 0x95, 0xcc, 0x38, 0x3d, 0x03, 0x1f, 0xeb, 0xf5, 0x37, + 0xce, 0xd7, 0x27, 0x7e, 0x3f, 0x02, 0xb5, 0x78, 0x12, 0x35, 0x8a, 0x26, 0x52, 0xa5, 0xdf, 0x3c, + 0x53, 0x95, 0x0e, 0x30, 0xd3, 0xd3, 0x25, 0x01, 0xa6, 0xf5, 0x65, 0x01, 0x96, 0xb5, 0x15, 0xab, + 0x7e, 0xae, 0xa5, 0x4a, 0xaa, 0x9f, 0x45, 0x94, 0x55, 0xbf, 0xbc, 0x13, 0xf4, 0xf9, 0xef, 0xd8, + 0x58, 0xe8, 0xdc, 0x7f, 0x71, 0x6c, 0x28, 0x2f, 0x8f, 0x0d, 0xe5, 0xf7, 0x63, 0x43, 0x79, 0x7a, + 0x62, 0xcc, 0xbc, 0x3c, 0x31, 0x66, 0x7e, 0x3d, 0x31, 0x66, 0xbe, 0xda, 0xf2, 0x7c, 0xba, 0x3f, + 0xea, 0x59, 0x7d, 0x1c, 0xc8, 0xbf, 0xab, 0x76, 0x61, 0x4e, 0xd0, 0x49, 0x84, 0x08, 0xfb, 0x73, + 0x5c, 0xe5, 0x6d, 0xf0, 0xce, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x12, 0xb3, 0x26, 0x14, 0x5c, + 0x0b, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -794,6 +929,10 @@ type MsgClient interface { // // Since: cosmos-sdk 0.47 UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error) + // CancelProposal defines a method to cancel governance proposal + // + // Since: cosmos-sdk 0.48 + CancelProposal(ctx context.Context, in *MsgCancelProposal, opts ...grpc.CallOption) (*MsgCancelProposalResponse, error) } type msgClient struct { @@ -858,6 +997,15 @@ func (c *msgClient) UpdateParams(ctx context.Context, in *MsgUpdateParams, opts return out, nil } +func (c *msgClient) CancelProposal(ctx context.Context, in *MsgCancelProposal, opts ...grpc.CallOption) (*MsgCancelProposalResponse, error) { + out := new(MsgCancelProposalResponse) + err := c.cc.Invoke(ctx, "/cosmos.gov.v1.Msg/CancelProposal", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + // MsgServer is the server API for Msg service. type MsgServer interface { // SubmitProposal defines a method to create new proposal given the messages. @@ -876,6 +1024,10 @@ type MsgServer interface { // // Since: cosmos-sdk 0.47 UpdateParams(context.Context, *MsgUpdateParams) (*MsgUpdateParamsResponse, error) + // CancelProposal defines a method to cancel governance proposal + // + // Since: cosmos-sdk 0.48 + CancelProposal(context.Context, *MsgCancelProposal) (*MsgCancelProposalResponse, error) } // UnimplementedMsgServer can be embedded to have forward compatible implementations. @@ -900,6 +1052,9 @@ func (*UnimplementedMsgServer) Deposit(ctx context.Context, req *MsgDeposit) (*M func (*UnimplementedMsgServer) UpdateParams(ctx context.Context, req *MsgUpdateParams) (*MsgUpdateParamsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method UpdateParams not implemented") } +func (*UnimplementedMsgServer) CancelProposal(ctx context.Context, req *MsgCancelProposal) (*MsgCancelProposalResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method CancelProposal not implemented") +} func RegisterMsgServer(s grpc1.Server, srv MsgServer) { s.RegisterService(&_Msg_serviceDesc, srv) @@ -1013,6 +1168,24 @@ func _Msg_UpdateParams_Handler(srv interface{}, ctx context.Context, dec func(in return interceptor(ctx, in, info, handler) } +func _Msg_CancelProposal_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgCancelProposal) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).CancelProposal(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmos.gov.v1.Msg/CancelProposal", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).CancelProposal(ctx, req.(*MsgCancelProposal)) + } + return interceptor(ctx, in, info, handler) +} + var _Msg_serviceDesc = grpc.ServiceDesc{ ServiceName: "cosmos.gov.v1.Msg", HandlerType: (*MsgServer)(nil), @@ -1041,6 +1214,10 @@ var _Msg_serviceDesc = grpc.ServiceDesc{ MethodName: "UpdateParams", Handler: _Msg_UpdateParams_Handler, }, + { + MethodName: "CancelProposal", + Handler: _Msg_CancelProposal_Handler, + }, }, Streams: []grpc.StreamDesc{}, Metadata: "cosmos/gov/v1/tx.proto", @@ -1502,6 +1679,82 @@ func (m *MsgUpdateParamsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) return len(dAtA) - i, nil } +func (m *MsgCancelProposal) 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 *MsgCancelProposal) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgCancelProposal) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Proposer) > 0 { + i -= len(m.Proposer) + copy(dAtA[i:], m.Proposer) + i = encodeVarintTx(dAtA, i, uint64(len(m.Proposer))) + i-- + dAtA[i] = 0x12 + } + if m.ProposalId != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.ProposalId)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *MsgCancelProposalResponse) 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 *MsgCancelProposalResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgCancelProposalResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.CanceledHeight != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.CanceledHeight)) + i-- + dAtA[i] = 0x18 + } + n3, err3 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.CanceledTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.CanceledTime):]) + if err3 != nil { + return 0, err3 + } + i -= n3 + i = encodeVarintTx(dAtA, i, uint64(n3)) + i-- + dAtA[i] = 0x12 + if m.ProposalId != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.ProposalId)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + func encodeVarintTx(dAtA []byte, offset int, v uint64) int { offset -= sovTx(v) base := offset @@ -1710,6 +1963,39 @@ func (m *MsgUpdateParamsResponse) Size() (n int) { return n } +func (m *MsgCancelProposal) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ProposalId != 0 { + n += 1 + sovTx(uint64(m.ProposalId)) + } + l = len(m.Proposer) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgCancelProposalResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ProposalId != 0 { + n += 1 + sovTx(uint64(m.ProposalId)) + } + l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.CanceledTime) + n += 1 + l + sovTx(uint64(l)) + if m.CanceledHeight != 0 { + n += 1 + sovTx(uint64(m.CanceledHeight)) + } + return n +} + func sovTx(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } @@ -2968,6 +3254,228 @@ func (m *MsgUpdateParamsResponse) Unmarshal(dAtA []byte) error { } return nil } +func (m *MsgCancelProposal) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgCancelProposal: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgCancelProposal: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposalId", wireType) + } + m.ProposalId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ProposalId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Proposer", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Proposer = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgCancelProposalResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgCancelProposalResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgCancelProposalResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ProposalId", wireType) + } + m.ProposalId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ProposalId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CanceledTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.CanceledTime, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CanceledHeight", wireType) + } + m.CanceledHeight = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CanceledHeight |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func skipTx(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0