LaconicNetwork/cosmos-sdk
10
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 2 Wiki Activity

basic migration for SubVote type

Browse Source
This commit is contained in:
antstalepresh 2020-10-27 21:50:11 +10:00
parent da0c3910a3
commit 09a282dda3
11 changed files with 482 additions and 263 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
proto/cosmos/gov/v1beta1/gov.proto
View File

@ -29,6 +29,15 @@ enum VoteOption {
VOTE_OPTION_NO_WITH_VETO = 4 [(gogoproto.enumvalue_customname) = "OptionNoWithVeto"];
}
message SubVote {
VoteOption option = 1;
string rate = 2 [
(gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec",
(gogoproto.nullable) = false,
(gogoproto.moretags) = "yaml:\"rate\""
];
}
// TextProposal defines a standard text proposal whose changes need to be
// manually updated in case of approval.
message TextProposal {
@ -119,9 +128,9 @@ message Vote {
option (gogoproto.goproto_stringer) = false;
option (gogoproto.equal) = false;
uint64 proposal_id = 1 [(gogoproto.moretags) = "yaml:\"proposal_id\""];
string voter = 2;
repeated VoteOption options = 3;
uint64 proposal_id = 1 [(gogoproto.moretags) = "yaml:\"proposal_id\""];
string voter = 2;
repeated SubVote sub_votes = 3 [(gogoproto.nullable) = false];
}
// DepositParams defines the params for deposits on governance proposals.

6
proto/cosmos/gov/v1beta1/tx.proto
View File

@ -50,9 +50,9 @@ message MsgVote {
option (gogoproto.stringer) = false;
option (gogoproto.goproto_getters) = false;
uint64 proposal_id = 1 [(gogoproto.jsontag) = "proposal_id", (gogoproto.moretags) = "yaml:\"proposal_id\""];
string voter = 2;
VoteOption option = 3;
uint64 proposal_id = 1 [(gogoproto.jsontag) = "proposal_id", (gogoproto.moretags) = "yaml:\"proposal_id\""];
string voter = 2;
repeated SubVote sub_votes = 3 [(gogoproto.nullable) = false];
}
// MsgVoteResponse defines the Msg/Vote response type.

2
x/gov/client/rest/tx.go
View File

@ -117,7 +117,7 @@ func newVoteHandlerFn(clientCtx client.Context) http.HandlerFunc {
}
// create the message
msg := types.NewMsgVote(req.Voter, proposalID, voteOption)
msg := types.NewMsgVote(req.Voter, proposalID, []types.SubVote{types.NewSubVote(voteOption, 1)})
if rest.CheckBadRequestError(w, msg.ValidateBasic()) {
return
}

4
x/gov/client/utils/query.go
View File

@ -101,7 +101,7 @@ func QueryVotesByTxQuery(clientCtx client.Context, params types.QueryProposalVot
votes = append(votes, types.Vote{
Voter: voteMsg.Voter,
ProposalId: params.ProposalID,
Option: voteMsg.Option,
SubVotes: voteMsg.SubVotes,
})
}
}
@ -148,7 +148,7 @@ func QueryVoteByTxQuery(clientCtx client.Context, params types.QueryVoteParams)
vote := types.Vote{
Voter: voteMsg.Voter,
ProposalId: params.ProposalID,
Option: voteMsg.Option,
SubVotes: voteMsg.SubVotes,
}
bz, err := clientCtx.JSONMarshaler.MarshalJSON(&vote)

2
x/gov/keeper/msg_server.go
View File

@ -64,7 +64,7 @@ func (k msgServer) Vote(goCtx context.Context, msg *types.MsgVote) (*types.MsgVo
if accErr != nil {
return nil, accErr
}
err := k.Keeper.AddVote(ctx, msg.ProposalId, accAddr, msg.Option)
err := k.Keeper.AddVote(ctx, msg.ProposalId, accAddr, msg.SubVotes)
if err != nil {
return nil, err
}

4
x/gov/keeper/vote.go
View File

@ -9,7 +9,7 @@ import (
)
// AddVote adds a vote on a specific proposal
func (keeper Keeper) AddVote(ctx sdk.Context, proposalID uint64, voterAddr sdk.AccAddress, option types.VoteOption) error {
func (keeper Keeper) AddVote(ctx sdk.Context, proposalID uint64, voterAddr sdk.AccAddress, subvotes []types.SubVote) error {
proposal, ok := keeper.GetProposal(ctx, proposalID)
if !ok {
return sdkerrors.Wrapf(types.ErrUnknownProposal, "%d", proposalID)
@ -22,7 +22,7 @@ func (keeper Keeper) AddVote(ctx sdk.Context, proposalID uint64, voterAddr sdk.A
return sdkerrors.Wrap(types.ErrInvalidVote, option.String())
}
vote := types.NewVote(proposalID, voterAddr, option)
vote := types.NewVote(proposalID, voterAddr, subvotes)
keeper.SetVote(ctx, vote)
ctx.EventManager().EmitEvent(

2
x/gov/legacy/v040/migrate.go
View File

@ -118,7 +118,7 @@ func Migrate(oldGovState v036gov.GenesisState) *v040gov.GenesisState {
newVotes[i] = v040gov.Vote{
ProposalId: oldVote.ProposalID,
Voter: oldVote.Voter.String(),
Option: migrateVoteOption(oldVote.Option),
SubVotes: []v040gov.SubVote{v040gov.NewSubVote(migrateVoteOption(oldVote.Option), 1)},
}
}

544
x/gov/types/gov.pb.go
View File

@ -121,6 +121,43 @@ func (ProposalStatus) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_6e82113c1a9a4b7c, []int{1}
}
type SubVote struct {
Option VoteOption `protobuf:"varint,1,opt,name=option,proto3,enum=cosmos.gov.v1beta1.VoteOption" json:"option,omitempty"`
Rate github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,2,opt,name=rate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"rate" yaml:"rate"`
}
func (m *SubVote) Reset() { *m = SubVote{} }
func (*SubVote) ProtoMessage() {}
func (*SubVote) Descriptor() ([]byte, []int) {
return fileDescriptor_6e82113c1a9a4b7c, []int{0}
}
func (m *SubVote) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *SubVote) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_SubVote.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 *SubVote) XXX_Merge(src proto.Message) {
xxx_messageInfo_SubVote.Merge(m, src)
}
func (m *SubVote) XXX_Size() int {
return m.Size()
}
func (m *SubVote) XXX_DiscardUnknown() {
xxx_messageInfo_SubVote.DiscardUnknown(m)
}
var xxx_messageInfo_SubVote proto.InternalMessageInfo
// TextProposal defines a standard text proposal whose changes need to be
// manually updated in case of approval.
type TextProposal struct {
@ -131,7 +168,7 @@ type TextProposal struct {
func (m *TextProposal) Reset() { *m = TextProposal{} }
func (*TextProposal) ProtoMessage() {}
func (*TextProposal) Descriptor() ([]byte, []int) {
return fileDescriptor_6e82113c1a9a4b7c, []int{0}
return fileDescriptor_6e82113c1a9a4b7c, []int{1}
}
func (m *TextProposal) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -171,7 +208,7 @@ type Deposit struct {
func (m *Deposit) Reset() { *m = Deposit{} }
func (*Deposit) ProtoMessage() {}
func (*Deposit) Descriptor() ([]byte, []int) {
return fileDescriptor_6e82113c1a9a4b7c, []int{1}
return fileDescriptor_6e82113c1a9a4b7c, []int{2}
}
func (m *Deposit) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -216,7 +253,7 @@ type Proposal struct {
func (m *Proposal) Reset() { *m = Proposal{} }
func (*Proposal) ProtoMessage() {}
func (*Proposal) Descriptor() ([]byte, []int) {
return fileDescriptor_6e82113c1a9a4b7c, []int{2}
return fileDescriptor_6e82113c1a9a4b7c, []int{3}
}
func (m *Proposal) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -256,7 +293,7 @@ type TallyResult struct {
func (m *TallyResult) Reset() { *m = TallyResult{} }
func (*TallyResult) ProtoMessage() {}
func (*TallyResult) Descriptor() ([]byte, []int) {
return fileDescriptor_6e82113c1a9a4b7c, []int{3}
return fileDescriptor_6e82113c1a9a4b7c, []int{4}
}
func (m *TallyResult) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -288,15 +325,15 @@ var xxx_messageInfo_TallyResult proto.InternalMessageInfo
// Vote defines a vote on a governance proposal.
// A Vote consists of a proposal ID, the voter, and the vote option.
type Vote struct {
ProposalId uint64 `protobuf:"varint,1,opt,name=proposal_id,json=proposalId,proto3" json:"proposal_id,omitempty" yaml:"proposal_id"`
Voter string `protobuf:"bytes,2,opt,name=voter,proto3" json:"voter,omitempty"`
Options []VoteOption `protobuf:"varint,3,rep,packed,name=options,proto3,enum=cosmos.gov.v1beta1.VoteOption" json:"options,omitempty"`
ProposalId uint64 `protobuf:"varint,1,opt,name=proposal_id,json=proposalId,proto3" json:"proposal_id,omitempty" yaml:"proposal_id"`
Voter string `protobuf:"bytes,2,opt,name=voter,proto3" json:"voter,omitempty"`
SubVotes []SubVote `protobuf:"bytes,3,rep,name=sub_votes,json=subVotes,proto3" json:"sub_votes"`
}
func (m *Vote) Reset() { *m = Vote{} }
func (*Vote) ProtoMessage() {}
func (*Vote) Descriptor() ([]byte, []int) {
return fileDescriptor_6e82113c1a9a4b7c, []int{4}
return fileDescriptor_6e82113c1a9a4b7c, []int{5}
}
func (m *Vote) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -337,7 +374,7 @@ type DepositParams struct {
func (m *DepositParams) Reset() { *m = DepositParams{} }
func (*DepositParams) ProtoMessage() {}
func (*DepositParams) Descriptor() ([]byte, []int) {
return fileDescriptor_6e82113c1a9a4b7c, []int{5}
return fileDescriptor_6e82113c1a9a4b7c, []int{6}
}
func (m *DepositParams) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -375,7 +412,7 @@ type VotingParams struct {
func (m *VotingParams) Reset() { *m = VotingParams{} }
func (*VotingParams) ProtoMessage() {}
func (*VotingParams) Descriptor() ([]byte, []int) {
return fileDescriptor_6e82113c1a9a4b7c, []int{6}
return fileDescriptor_6e82113c1a9a4b7c, []int{7}
}
func (m *VotingParams) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -419,7 +456,7 @@ type TallyParams struct {
func (m *TallyParams) Reset() { *m = TallyParams{} }
func (*TallyParams) ProtoMessage() {}
func (*TallyParams) Descriptor() ([]byte, []int) {
return fileDescriptor_6e82113c1a9a4b7c, []int{7}
return fileDescriptor_6e82113c1a9a4b7c, []int{8}
}
func (m *TallyParams) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -451,6 +488,7 @@ var xxx_messageInfo_TallyParams proto.InternalMessageInfo
func init() {
proto.RegisterEnum("cosmos.gov.v1beta1.VoteOption", VoteOption_name, VoteOption_value)
proto.RegisterEnum("cosmos.gov.v1beta1.ProposalStatus", ProposalStatus_name, ProposalStatus_value)
proto.RegisterType((*SubVote)(nil), "cosmos.gov.v1beta1.SubVote")
proto.RegisterType((*TextProposal)(nil), "cosmos.gov.v1beta1.TextProposal")
proto.RegisterType((*Deposit)(nil), "cosmos.gov.v1beta1.Deposit")
proto.RegisterType((*Proposal)(nil), "cosmos.gov.v1beta1.Proposal")
@ -464,94 +502,98 @@ func init() {
func init() { proto.RegisterFile("cosmos/gov/v1beta1/gov.proto", fileDescriptor_6e82113c1a9a4b7c) }
var fileDescriptor_6e82113c1a9a4b7c = []byte{
// 1380 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x57, 0x5f, 0x6c, 0xdb, 0xd4,
0x17, 0x8e, 0xd3, 0xff, 0x37, 0x69, 0xea, 0xdd, 0x66, 0x6d, 0xea, 0xdf, 0x7e, 0xb6, 0x31, 0x08,
0x55, 0xd3, 0x96, 0x6e, 0x05, 0x09, 0xe8, 0x24, 0x44, 0xd2, 0x78, 0x2c, 0x68, 0x4a, 0x22, 0xc7,
0xcb, 0xb4, 0xf1, 0x60, 0x39, 0xc9, 0x5d, 0x6a, 0x88, 0x7d, 0x43, 0x7c, 0x53, 0x1a, 0xf1, 0xc2,
0xe3, 0x14, 0x24, 0xb4, 0xc7, 0x21, 0x14, 0x69, 0x12, 0x6f, 0x3c, 0xf3, 0xcc, 0x73, 0x85, 0x90,
0x98, 0x78, 0x9a, 0x40, 0xca, 0x58, 0x27, 0xa1, 0xa9, 0x8f, 0x7d, 0xe0, 0x19, 0xd9, 0xf7, 0xba,
0x71, 0x92, 0x8a, 0x12, 0x9e, 0x66, 0x9f, 0x7b, 0xbe, 0xef, 0x3b, 0xf7, 0xf3, 0x39, 0x27, 0x2b,
0xb8, 0x54, 0xc3, 0xae, 0x8d, 0xdd, 0xad, 0x06, 0xde, 0xdf, 0xda, 0xbf, 0x5e, 0x45, 0xc4, 0xbc,
0xee, 0x3d, 0xa7, 0x5b, 0x6d, 0x4c, 0x30, 0x84, 0xf4, 0x34, 0xed, 0x45, 0xd8, 0xa9, 0x20, 0x32,
0x44, 0xd5, 0x74, 0xd1, 0x29, 0xa4, 0x86, 0x2d, 0x87, 0x62, 0x84, 0x64, 0x03, 0x37, 0xb0, 0xff,
0xb8, 0xe5, 0x3d, 0xb1, 0xe8, 0x06, 0x45, 0x19, 0xf4, 0x80, 0xd1, 0xd2, 0x23, 0xa9, 0x81, 0x71,
0xa3, 0x89, 0xb6, 0xfc, 0xb7, 0x6a, 0xe7, 0xc1, 0x16, 0xb1, 0x6c, 0xe4, 0x12, 0xd3, 0x6e, 0x05,
0xd8, 0xf1, 0x04, 0xd3, 0xe9, 0xb2, 0x23, 0x71, 0xfc, 0xa8, 0xde, 0x69, 0x9b, 0xc4, 0xc2, 0xac,
0x18, 0xe5, 0x2e, 0x88, 0xeb, 0xe8, 0x80, 0x94, 0xda, 0xb8, 0x85, 0x5d, 0xb3, 0x09, 0x93, 0x60,
0x8e, 0x58, 0xa4, 0x89, 0x52, 0x9c, 0xcc, 0x6d, 0x2e, 0x69, 0xf4, 0x05, 0xca, 0x20, 0x56, 0x47,
0x6e, 0xad, 0x6d, 0xb5, 0x3c, 0x68, 0x2a, 0xea, 0x9f, 0x85, 0x43, 0x3b, 0x2b, 0xaf, 0x9e, 0x48,
0xdc, 0xaf, 0x3f, 0x5c, 0x5d, 0xd8, 0xc5, 0x0e, 0x41, 0x0e, 0x51, 0x7e, 0xe1, 0xc0, 0x42, 0x0e,
0xb5, 0xb0, 0x6b, 0x11, 0xf8, 0x0e, 0x88, 0xb5, 0x98, 0x80, 0x61, 0xd5, 0x7d, 0xea, 0xd9, 0xec,
0xda, 0xc9, 0x40, 0x82, 0x5d, 0xd3, 0x6e, 0xee, 0x28, 0xa1, 0x43, 0x45, 0x03, 0xc1, 0x5b, 0xbe,
0x0e, 0x2f, 0x81, 0xa5, 0x3a, 0xe5, 0xc0, 0x6d, 0xa6, 0x3a, 0x0c, 0xc0, 0x1a, 0x98, 0x37, 0x6d,
0xdc, 0x71, 0x48, 0x6a, 0x46, 0x9e, 0xd9, 0x8c, 0x6d, 0x6f, 0xa4, 0x99, 0x6d, 0x9e, 0xf3, 0xc1,
0xe7, 0x48, 0xef, 0x62, 0xcb, 0xc9, 0x5e, 0x3b, 0x1c, 0x48, 0x91, 0xef, 0x9f, 0x4b, 0x9b, 0x0d,
0x8b, 0xec, 0x75, 0xaa, 0xe9, 0x1a, 0xb6, 0x99, 0xc7, 0xec, 0x9f, 0xab, 0x6e, 0xfd, 0xd3, 0x2d,
0xd2, 0x6d, 0x21, 0xd7, 0x07, 0xb8, 0x1a, 0xa3, 0xde, 0x59, 0x7c, 0xf8, 0x44, 0x8a, 0xbc, 0x7a,
0x22, 0x45, 0x94, 0xbf, 0xe6, 0xc1, 0xe2, 0xa9, 0x4f, 0x6f, 0x9f, 0x75, 0xa5, 0xd5, 0xe3, 0x81,
0x14, 0xb5, 0xea, 0x27, 0x03, 0x69, 0x89, 0x5e, 0x6c, 0xfc, 0x3e, 0x37, 0xc0, 0x42, 0x8d, 0xfa,
0xe3, 0xdf, 0x26, 0xb6, 0x9d, 0x4c, 0xd3, 0xef, 0x93, 0x0e, 0xbe, 0x4f, 0x3a, 0xe3, 0x74, 0xb3,
0xb1, 0x9f, 0x86, 0x46, 0x6a, 0x01, 0x02, 0x56, 0xc0, 0xbc, 0x4b, 0x4c, 0xd2, 0x71, 0x53, 0x33,
0x32, 0xb7, 0x99, 0xd8, 0x56, 0xd2, 0x93, 0xcd, 0x97, 0x0e, 0x0a, 0x2c, 0xfb, 0x99, 0x59, 0xe1,
0x64, 0x20, 0xad, 0x8d, 0x99, 0x4c, 0x49, 0x14, 0x8d, 0xb1, 0xc1, 0x16, 0x80, 0x0f, 0x2c, 0xc7,
0x6c, 0x1a, 0xc4, 0x6c, 0x36, 0xbb, 0x46, 0x1b, 0xb9, 0x9d, 0x26, 0x49, 0xcd, 0xfa, 0xf5, 0x49,
0x67, 0x69, 0xe8, 0x5e, 0x9e, 0xe6, 0xa7, 0x65, 0x5f, 0xf3, 0x8c, 0x3d, 0x19, 0x48, 0x1b, 0x54,
0x64, 0x92, 0x48, 0xd1, 0x78, 0x3f, 0x18, 0x02, 0xc1, 0x8f, 0x41, 0xcc, 0xed, 0x54, 0x6d, 0x8b,
0x18, 0x5e, 0x27, 0xa7, 0xe6, 0x7c, 0x29, 0x61, 0xc2, 0x0a, 0x3d, 0x68, 0xf3, 0xac, 0xc8, 0x54,
0x58, 0xbf, 0x84, 0xc0, 0xca, 0xa3, 0xe7, 0x12, 0xa7, 0x01, 0x1a, 0xf1, 0x00, 0xd0, 0x02, 0x3c,
0x6b, 0x11, 0x03, 0x39, 0x75, 0xaa, 0x30, 0x7f, 0xae, 0xc2, 0xeb, 0x4c, 0x61, 0x9d, 0x2a, 0x8c,
0x33, 0x50, 0x99, 0x04, 0x0b, 0xab, 0x4e, 0xdd, 0x97, 0x7a, 0xc8, 0x81, 0x65, 0x82, 0x89, 0xd9,
0x34, 0xd8, 0x41, 0x6a, 0xe1, 0xbc, 0x46, 0xbc, 0xc5, 0x74, 0x92, 0x54, 0x67, 0x04, 0xad, 0x4c,
0xd5, 0xa0, 0x71, 0x1f, 0x1b, 0x8c, 0x58, 0x13, 0x5c, 0xd8, 0xc7, 0xc4, 0x72, 0x1a, 0xde, 0xe7,
0x6d, 0x33, 0x63, 0x17, 0xcf, 0xbd, 0xf6, 0x1b, 0xac, 0x9c, 0x14, 0x2d, 0x67, 0x82, 0x82, 0xde,
0x7b, 0x85, 0xc6, 0xcb, 0x5e, 0xd8, 0xbf, 0xf8, 0x03, 0xc0, 0x42, 0x43, 0x8b, 0x97, 0xce, 0xd5,
0x52, 0x98, 0xd6, 0xda, 0x88, 0xd6, 0xa8, 0xc3, 0xcb, 0x34, 0xca, 0x0c, 0xde, 0x99, 0xf5, 0xb6,
0x8a, 0x72, 0x18, 0x05, 0xb1, 0x70, 0xfb, 0x7c, 0x00, 0x66, 0xba, 0xc8, 0xa5, 0x1b, 0x2a, 0x9b,
0xf6, 0x58, 0x7f, 0x1b, 0x48, 0x6f, 0xfe, 0x0b, 0xe3, 0xf2, 0x0e, 0xd1, 0x3c, 0x28, 0xbc, 0x05,
0x16, 0xcc, 0xaa, 0x4b, 0x4c, 0x8b, 0xed, 0xb2, 0xa9, 0x59, 0x02, 0x38, 0x7c, 0x1f, 0x44, 0x1d,
0xec, 0x0f, 0xe4, 0xf4, 0x24, 0x51, 0x07, 0xc3, 0x06, 0x88, 0x3b, 0xd8, 0xf8, 0xdc, 0x22, 0x7b,
0xc6, 0x3e, 0x22, 0xd8, 0x1f, 0xbb, 0xa5, 0xac, 0x3a, 0x1d, 0xd3, 0xc9, 0x40, 0x5a, 0xa5, 0xa6,
0x86, 0xb9, 0x14, 0x0d, 0x38, 0xf8, 0xae, 0x45, 0xf6, 0x2a, 0x88, 0x60, 0x66, 0xe5, 0x37, 0x1c,
0x98, 0xad, 0x60, 0x82, 0xfe, 0xfb, 0x4a, 0x4e, 0x82, 0xb9, 0x7d, 0x4c, 0x50, 0xb0, 0x8e, 0xe9,
0x0b, 0x7c, 0x17, 0x2c, 0x60, 0xff, 0x87, 0xc0, 0xf5, 0x77, 0x71, 0x62, 0x5b, 0x3c, 0x6b, 0x71,
0x78, 0xca, 0x45, 0x3f, 0x4d, 0x0b, 0xd2, 0x77, 0x16, 0x1f, 0x07, 0xfb, 0xf5, 0xc7, 0x28, 0x58,
0x66, 0xed, 0x5c, 0x32, 0xdb, 0xa6, 0xed, 0xc2, 0x6f, 0x39, 0x10, 0xb3, 0x2d, 0xe7, 0x74, 0xba,
0xb8, 0xf3, 0xa6, 0xcb, 0xf0, 0x7c, 0x3b, 0x1e, 0x48, 0x17, 0x43, 0xa8, 0x2b, 0xd8, 0xb6, 0x08,
0xb2, 0x5b, 0xa4, 0x3b, 0xbc, 0x5d, 0xe8, 0x78, 0xba, 0xa1, 0x03, 0xb6, 0xe5, 0x04, 0x23, 0xf7,
0x35, 0x07, 0xa0, 0x6d, 0x1e, 0x04, 0x44, 0x46, 0x0b, 0xb5, 0x2d, 0x5c, 0x67, 0x8b, 0x7d, 0x63,
0x62, 0x10, 0x72, 0xec, 0x87, 0x97, 0x7e, 0xdc, 0xe3, 0x81, 0x74, 0x69, 0x12, 0x3c, 0x52, 0x2b,
0x5b, 0xa9, 0x93, 0x59, 0xca, 0x63, 0x6f, 0x54, 0x78, 0xdb, 0x3c, 0x08, 0xec, 0xa2, 0xe1, 0xaf,
0x38, 0x10, 0xaf, 0xf8, 0xf3, 0xc3, 0xfc, 0xfb, 0x02, 0xb0, 0x79, 0x0a, 0x6a, 0xe3, 0xce, 0xab,
0xed, 0x06, 0xab, 0x6d, 0x7d, 0x04, 0x37, 0x52, 0x56, 0x72, 0x64, 0x7c, 0xc3, 0x15, 0xc5, 0x69,
0x8c, 0x55, 0xf3, 0x7b, 0x30, 0xb5, 0xac, 0x98, 0xfb, 0x60, 0xfe, 0xb3, 0x0e, 0x6e, 0x77, 0x6c,
0xbf, 0x8a, 0x78, 0x36, 0x3b, 0x45, 0x8f, 0xe7, 0x50, 0xed, 0x78, 0x20, 0xf1, 0x14, 0x3f, 0xac,
0x46, 0x63, 0x8c, 0xb0, 0x06, 0x96, 0xc8, 0x5e, 0x1b, 0xb9, 0x7b, 0xb8, 0x49, 0x3f, 0x40, 0x7c,
0xaa, 0x11, 0xa2, 0xf4, 0xab, 0xa7, 0x14, 0x21, 0x85, 0x21, 0x2f, 0xec, 0x71, 0x20, 0xe1, 0xcd,
0x95, 0x31, 0x94, 0x9a, 0xf1, 0xa5, 0x6a, 0x53, 0x4b, 0xa5, 0x46, 0x79, 0x46, 0xfc, 0xbd, 0xc8,
0xfc, 0x1d, 0xc9, 0x50, 0xb4, 0x65, 0x2f, 0xa0, 0x07, 0xef, 0x97, 0xff, 0xe4, 0x00, 0x18, 0x8e,
0x13, 0xbc, 0x02, 0xd6, 0x2b, 0x45, 0x5d, 0x35, 0x8a, 0x25, 0x3d, 0x5f, 0x2c, 0x18, 0x77, 0x0a,
0xe5, 0x92, 0xba, 0x9b, 0xbf, 0x99, 0x57, 0x73, 0x7c, 0x44, 0x58, 0xe9, 0xf5, 0xe5, 0x18, 0x4d,
0x54, 0x3d, 0x11, 0xa8, 0x80, 0x95, 0x70, 0xf6, 0x3d, 0xb5, 0xcc, 0x73, 0xc2, 0x72, 0xaf, 0x2f,
0x2f, 0xd1, 0xac, 0x7b, 0xc8, 0x85, 0x97, 0xc1, 0x6a, 0x38, 0x27, 0x93, 0x2d, 0xeb, 0x99, 0x7c,
0x81, 0x8f, 0x0a, 0x17, 0x7a, 0x7d, 0x79, 0x99, 0xe6, 0x65, 0xd8, 0x12, 0x94, 0x41, 0x22, 0x9c,
0x5b, 0x28, 0xf2, 0x33, 0x42, 0xbc, 0xd7, 0x97, 0x17, 0x69, 0x5a, 0x01, 0xc3, 0x6d, 0x90, 0x1a,
0xcd, 0x30, 0xee, 0xe6, 0xf5, 0x5b, 0x46, 0x45, 0xd5, 0x8b, 0xfc, 0xac, 0x90, 0xec, 0xf5, 0x65,
0x3e, 0xc8, 0x0d, 0x36, 0x96, 0x30, 0xfb, 0xf0, 0x3b, 0x31, 0x72, 0xf9, 0xe7, 0x28, 0x48, 0x8c,
0xfe, 0xa7, 0x06, 0xa6, 0xc1, 0xff, 0x4a, 0x5a, 0xb1, 0x54, 0x2c, 0x67, 0x6e, 0x1b, 0x65, 0x3d,
0xa3, 0xdf, 0x29, 0x8f, 0x5d, 0xd8, 0xbf, 0x0a, 0x4d, 0x2e, 0x58, 0x4d, 0x78, 0x03, 0x88, 0xe3,
0xf9, 0x39, 0xb5, 0x54, 0x2c, 0xe7, 0x75, 0xa3, 0xa4, 0x6a, 0xf9, 0x62, 0x8e, 0xe7, 0x84, 0xf5,
0x5e, 0x5f, 0x5e, 0xa5, 0x90, 0x91, 0xa1, 0x82, 0xef, 0x81, 0xff, 0x8f, 0x83, 0x2b, 0x45, 0x3d,
0x5f, 0xf8, 0x30, 0xc0, 0x46, 0x85, 0xb5, 0x5e, 0x5f, 0x86, 0x14, 0x5b, 0x09, 0x4d, 0x00, 0xbc,
0x02, 0xd6, 0xc6, 0xa1, 0xa5, 0x4c, 0xb9, 0xac, 0xe6, 0xf8, 0x19, 0x81, 0xef, 0xf5, 0xe5, 0x38,
0xc5, 0x94, 0x4c, 0xd7, 0x45, 0x75, 0x78, 0x0d, 0xa4, 0xc6, 0xb3, 0x35, 0xf5, 0x23, 0x75, 0x57,
0x57, 0x73, 0xfc, 0xac, 0x00, 0x7b, 0x7d, 0x39, 0x41, 0xf3, 0x35, 0xf4, 0x09, 0xaa, 0x11, 0x74,
0x26, 0xff, 0xcd, 0x4c, 0xfe, 0xb6, 0x9a, 0xe3, 0xe7, 0xc2, 0xfc, 0x37, 0x4d, 0xab, 0x89, 0xea,
0xd4, 0xce, 0x6c, 0xe1, 0xf0, 0x85, 0x18, 0x79, 0xf6, 0x42, 0x8c, 0x7c, 0x79, 0x24, 0x46, 0x0e,
0x8f, 0x44, 0xee, 0xe9, 0x91, 0xc8, 0xfd, 0x71, 0x24, 0x72, 0x8f, 0x5e, 0x8a, 0x91, 0xa7, 0x2f,
0xc5, 0xc8, 0xb3, 0x97, 0x62, 0xe4, 0xfe, 0x3f, 0x2f, 0xc4, 0x03, 0xff, 0x8f, 0x21, 0xbf, 0x9f,
0xab, 0xf3, 0xfe, 0x0e, 0x79, 0xeb, 0xef, 0x00, 0x00, 0x00, 0xff, 0xff, 0xd9, 0xc3, 0x29, 0xda,
0x27, 0x0d, 0x00, 0x00,
// 1442 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x57, 0x5f, 0x6c, 0xdb, 0x54,
0x17, 0x8f, 0xd3, 0xf4, 0x4f, 0x6e, 0xd2, 0xd6, 0xbb, 0xed, 0xda, 0x34, 0xdb, 0x67, 0xfb, 0xf3,
0xf7, 0x09, 0x55, 0xd3, 0x96, 0x6e, 0x05, 0x81, 0xe8, 0xc4, 0x44, 0xdc, 0x78, 0x2c, 0x68, 0x4a,
0x82, 0xe3, 0x65, 0xda, 0x78, 0xb0, 0x9c, 0xe4, 0x2e, 0x35, 0xc4, 0xbe, 0x21, 0xbe, 0x29, 0xad,
0x78, 0xe1, 0x71, 0x0a, 0x12, 0xda, 0x03, 0x0f, 0x93, 0x50, 0xc4, 0x24, 0xde, 0x78, 0xe6, 0x99,
0xe7, 0x0a, 0x21, 0x31, 0xf1, 0x34, 0x81, 0x94, 0xb1, 0x4e, 0x42, 0x53, 0x1f, 0xfb, 0xc0, 0x33,
0xb2, 0xef, 0x75, 0xe3, 0x24, 0x15, 0x25, 0x3c, 0xd5, 0xf7, 0xdc, 0xf3, 0xfb, 0xfd, 0xce, 0x39,
0x3e, 0xe7, 0xc4, 0x05, 0x17, 0x6b, 0xd8, 0xb5, 0xb1, 0xbb, 0xd1, 0xc0, 0xbb, 0x1b, 0xbb, 0xd7,
0xaa, 0x88, 0x98, 0xd7, 0xbc, 0xe7, 0x4c, 0xab, 0x8d, 0x09, 0x86, 0x90, 0xde, 0x66, 0x3c, 0x0b,
0xbb, 0x4d, 0x0b, 0x0c, 0x51, 0x35, 0x5d, 0x74, 0x02, 0xa9, 0x61, 0xcb, 0xa1, 0x98, 0xf4, 0x72,
0x03, 0x37, 0xb0, 0xff, 0xb8, 0xe1, 0x3d, 0x31, 0xeb, 0x1a, 0x45, 0x19, 0xf4, 0x82, 0xd1, 0xd2,
0x2b, 0xb1, 0x81, 0x71, 0xa3, 0x89, 0x36, 0xfc, 0x53, 0xb5, 0xf3, 0x60, 0x83, 0x58, 0x36, 0x72,
0x89, 0x69, 0xb7, 0x02, 0xec, 0xa8, 0x83, 0xe9, 0xec, 0xb3, 0x2b, 0x61, 0xf4, 0xaa, 0xde, 0x69,
0x9b, 0xc4, 0xc2, 0x2c, 0x18, 0xf9, 0x2b, 0x0e, 0xcc, 0x96, 0x3b, 0xd5, 0x0a, 0x26, 0x08, 0xbe,
0x09, 0x66, 0x70, 0xcb, 0xbb, 0x4b, 0x71, 0x12, 0xb7, 0xbe, 0xb0, 0x29, 0x64, 0xc6, 0xb3, 0xcb,
0x78, 0x9e, 0x45, 0xdf, 0x4b, 0x63, 0xde, 0xf0, 0x03, 0x10, 0x6b, 0x9b, 0x04, 0xa5, 0xa2, 0x12,
0xb7, 0x1e, 0x57, 0xde, 0x39, 0xe8, 0x8b, 0x91, 0x5f, 0xfb, 0xe2, 0x6b, 0x0d, 0x8b, 0xec, 0x74,
0xaa, 0x99, 0x1a, 0xb6, 0x59, 0x3a, 0xec, 0xcf, 0x15, 0xb7, 0xfe, 0xf1, 0x06, 0xd9, 0x6f, 0x21,
0x37, 0x93, 0x43, 0xb5, 0xe3, 0xbe, 0x98, 0xd8, 0x37, 0xed, 0xe6, 0x96, 0xec, 0x71, 0xc8, 0x9a,
0x4f, 0x25, 0xdf, 0x05, 0x49, 0x1d, 0xed, 0x91, 0x52, 0x1b, 0xb7, 0xb0, 0x6b, 0x36, 0xe1, 0x32,
0x98, 0x26, 0x16, 0x69, 0x22, 0x3f, 0xb2, 0xb8, 0x46, 0x0f, 0x50, 0x02, 0x89, 0x3a, 0x72, 0x6b,
0x6d, 0x8b, 0x46, 0xed, 0xeb, 0x6b, 0x61, 0xd3, 0xd6, 0xe2, 0xab, 0x27, 0x22, 0xf7, 0xcb, 0xf7,
0x57, 0x66, 0xb7, 0xb1, 0x43, 0x90, 0x43, 0xe4, 0x9f, 0x39, 0x30, 0x9b, 0x43, 0x2d, 0xec, 0x5a,
0x04, 0xbe, 0x05, 0x12, 0x2d, 0x26, 0x60, 0x58, 0x75, 0x9f, 0x3a, 0xa6, 0xac, 0x1c, 0xf7, 0x45,
0x48, 0x03, 0x0a, 0x5d, 0xca, 0x1a, 0x08, 0x4e, 0xf9, 0x3a, 0xbc, 0x08, 0xe2, 0x75, 0xca, 0x81,
0xdb, 0x4c, 0x75, 0x60, 0x80, 0x35, 0x30, 0x63, 0xda, 0xb8, 0xe3, 0x90, 0xd4, 0x94, 0x34, 0xb5,
0x9e, 0xd8, 0x5c, 0x0b, 0xca, 0xe8, 0x35, 0xc4, 0x49, 0x1d, 0xb7, 0xb1, 0xe5, 0x28, 0x57, 0xbd,
0x5a, 0x7d, 0xf7, 0x5c, 0x5c, 0xff, 0x07, 0xb5, 0xf2, 0x00, 0xae, 0xc6, 0xa8, 0xb7, 0xe6, 0x1e,
0x3e, 0x11, 0x23, 0xaf, 0x9e, 0x88, 0x11, 0xf9, 0xcf, 0x19, 0x30, 0x77, 0x52, 0xa7, 0x37, 0x4e,
0x4b, 0x69, 0xe9, 0xa8, 0x2f, 0x46, 0xad, 0xfa, 0x71, 0x5f, 0x8c, 0xd3, 0xc4, 0x46, 0xf3, 0xb9,
0x0e, 0x66, 0x6b, 0xb4, 0x3e, 0x7e, 0x36, 0x89, 0xcd, 0xe5, 0x0c, 0x6d, 0x9b, 0x4c, 0xd0, 0x36,
0x99, 0xac, 0xb3, 0xaf, 0x24, 0x7e, 0x1c, 0x14, 0x52, 0x0b, 0x10, 0xb0, 0x02, 0x66, 0x5c, 0x62,
0x92, 0x8e, 0x9b, 0x9a, 0xf2, 0xbb, 0x46, 0x3e, 0xad, 0x6b, 0x82, 0x00, 0xcb, 0xbe, 0xa7, 0x92,
0x3e, 0xee, 0x8b, 0x2b, 0x23, 0x45, 0xa6, 0x24, 0xb2, 0xc6, 0xd8, 0x60, 0x0b, 0xc0, 0x07, 0x96,
0x63, 0x36, 0x0d, 0x62, 0x36, 0x9b, 0xfb, 0x46, 0x1b, 0xb9, 0x9d, 0x26, 0x49, 0xc5, 0xfc, 0xf8,
0xc4, 0xd3, 0x34, 0x74, 0xcf, 0x4f, 0xf3, 0xdd, 0x94, 0xff, 0x7a, 0x85, 0x3d, 0xee, 0x8b, 0x6b,
0x54, 0x64, 0x9c, 0x48, 0xd6, 0x78, 0xdf, 0x18, 0x02, 0xc1, 0x0f, 0x41, 0xc2, 0xed, 0x54, 0x6d,
0x8b, 0x18, 0xde, 0x80, 0xa5, 0xa6, 0x7d, 0xa9, 0xf4, 0x58, 0x29, 0xf4, 0x60, 0xfa, 0x14, 0x81,
0xa9, 0xb0, 0x7e, 0x09, 0x81, 0xe5, 0x47, 0xcf, 0x45, 0x4e, 0x03, 0xd4, 0xe2, 0x01, 0xa0, 0x05,
0x78, 0xd6, 0x22, 0x06, 0x72, 0xea, 0x54, 0x61, 0xe6, 0x4c, 0x85, 0xff, 0x31, 0x85, 0x55, 0xaa,
0x30, 0xca, 0x40, 0x65, 0x16, 0x98, 0x59, 0x75, 0xea, 0xbe, 0xd4, 0x43, 0x0e, 0xcc, 0x13, 0x4c,
0xcc, 0xa6, 0xc1, 0x2e, 0x52, 0xb3, 0x67, 0x35, 0xe2, 0x2d, 0xa6, 0xb3, 0x4c, 0x75, 0x86, 0xd0,
0xf2, 0x44, 0x0d, 0x9a, 0xf4, 0xb1, 0xc1, 0x88, 0x35, 0xc1, 0xb9, 0x5d, 0x4c, 0x2c, 0xa7, 0xe1,
0xbd, 0xde, 0x36, 0x2b, 0xec, 0xdc, 0x99, 0x69, 0xff, 0x9f, 0x85, 0x93, 0xa2, 0xe1, 0x8c, 0x51,
0xd0, 0xbc, 0x17, 0xa9, 0xbd, 0xec, 0x99, 0xfd, 0xc4, 0x1f, 0x00, 0x66, 0x1a, 0x94, 0x38, 0x7e,
0xa6, 0x96, 0xcc, 0xb4, 0x56, 0x86, 0xb4, 0x86, 0x2b, 0x3c, 0x4f, 0xad, 0xac, 0xc0, 0x5b, 0x31,
0x6f, 0xab, 0xc8, 0x07, 0x51, 0x90, 0x08, 0xb7, 0xcf, 0xbb, 0x60, 0x6a, 0x1f, 0xb9, 0x74, 0x43,
0x29, 0x99, 0x09, 0xb6, 0x60, 0xde, 0x21, 0x9a, 0x07, 0x85, 0xb7, 0xc0, 0xac, 0x59, 0x75, 0x89,
0x69, 0xb1, 0x5d, 0x36, 0x31, 0x4b, 0x00, 0x87, 0x37, 0x40, 0xd4, 0xc1, 0xfe, 0x40, 0x4e, 0x4e,
0x12, 0x75, 0x30, 0x6c, 0x80, 0xa4, 0x83, 0x8d, 0x4f, 0x2d, 0xb2, 0x63, 0xec, 0x22, 0x82, 0xfd,
0xb1, 0x8b, 0x2b, 0xea, 0x64, 0x4c, 0xc7, 0x7d, 0x71, 0x89, 0x16, 0x35, 0xcc, 0x25, 0x6b, 0xc0,
0xc1, 0x77, 0x2d, 0xb2, 0x53, 0x41, 0x04, 0xb3, 0x52, 0x7e, 0xc3, 0x81, 0x98, 0xff, 0x13, 0xf4,
0xaf, 0x57, 0xf2, 0x32, 0x98, 0xde, 0xc5, 0x04, 0x05, 0xeb, 0x98, 0x1e, 0xe0, 0x0d, 0x10, 0x77,
0x3b, 0x55, 0xc3, 0x3b, 0xb8, 0x6c, 0x1b, 0x5f, 0x38, 0x6d, 0x75, 0xb0, 0x5f, 0x40, 0x25, 0xe6,
0x25, 0xa8, 0xcd, 0xb9, 0xf4, 0xe8, 0x6e, 0xcd, 0x3d, 0x0e, 0xb6, 0xec, 0x0f, 0x51, 0x30, 0xcf,
0x9a, 0xba, 0x64, 0xb6, 0x4d, 0xdb, 0x85, 0x5f, 0x73, 0x20, 0x61, 0x5b, 0xce, 0xc9, 0x8c, 0x71,
0x67, 0xcd, 0x98, 0xe1, 0x91, 0x1f, 0xf5, 0xc5, 0xf3, 0x21, 0xd4, 0x65, 0x6c, 0x5b, 0x04, 0xd9,
0x2d, 0xb2, 0x3f, 0xc8, 0x31, 0x74, 0x3d, 0xd9, 0xe8, 0x01, 0xdb, 0x72, 0x82, 0xc1, 0xfb, 0x92,
0x03, 0xd0, 0x36, 0xf7, 0x02, 0x22, 0xa3, 0x85, 0xda, 0x16, 0xae, 0xb3, 0xf5, 0xbe, 0x36, 0x36,
0x0e, 0x39, 0xf6, 0x55, 0x40, 0x5f, 0xf1, 0x51, 0x5f, 0xbc, 0x38, 0x0e, 0x1e, 0x8a, 0x95, 0x2d,
0xd6, 0x71, 0x2f, 0xf9, 0xb1, 0x37, 0x30, 0xbc, 0x6d, 0xee, 0x05, 0xe5, 0xa2, 0xe6, 0x2f, 0x38,
0x90, 0xac, 0xf8, 0x53, 0xc4, 0xea, 0xf7, 0x19, 0x60, 0x53, 0x15, 0xc4, 0xc6, 0x9d, 0x15, 0xdb,
0x75, 0x16, 0xdb, 0xea, 0x10, 0x6e, 0x28, 0xac, 0xe5, 0xa1, 0x21, 0x0e, 0x47, 0x94, 0xa4, 0x36,
0x16, 0xcd, 0x6f, 0xc1, 0xec, 0xb2, 0x60, 0xee, 0x83, 0x99, 0x4f, 0x3a, 0xb8, 0xdd, 0xb1, 0xfd,
0x28, 0x92, 0x8a, 0x32, 0xd9, 0x47, 0xcc, 0x51, 0x5f, 0xe4, 0x29, 0x7e, 0x10, 0x8d, 0xc6, 0x18,
0x61, 0x0d, 0xc4, 0xc9, 0x4e, 0x1b, 0xb9, 0x3b, 0xb8, 0x49, 0x5f, 0x40, 0x72, 0xa2, 0x41, 0xa2,
0xf4, 0x4b, 0x27, 0x14, 0x21, 0x85, 0x01, 0x2f, 0xec, 0x72, 0x60, 0xc1, 0x9b, 0x2e, 0x63, 0x20,
0x35, 0xe5, 0x4b, 0xd5, 0x26, 0x96, 0x4a, 0x0d, 0xf3, 0x0c, 0xd5, 0xf7, 0x3c, 0xab, 0xef, 0x90,
0x87, 0xac, 0xcd, 0x7b, 0x06, 0x3d, 0x38, 0x5f, 0xfa, 0x83, 0x03, 0x60, 0xf0, 0x9d, 0x08, 0x2f,
0x83, 0xd5, 0x4a, 0x51, 0x57, 0x8d, 0x62, 0x49, 0xcf, 0x17, 0x0b, 0xc6, 0x9d, 0x42, 0xb9, 0xa4,
0x6e, 0xe7, 0x6f, 0xe6, 0xd5, 0x1c, 0x1f, 0x49, 0x2f, 0x76, 0x7b, 0x52, 0x82, 0x3a, 0xaa, 0x9e,
0x08, 0x94, 0xc1, 0x62, 0xd8, 0xfb, 0x9e, 0x5a, 0xe6, 0xb9, 0xf4, 0x7c, 0xb7, 0x27, 0xc5, 0xa9,
0xd7, 0x3d, 0xe4, 0xc2, 0x4b, 0x60, 0x29, 0xec, 0x93, 0x55, 0xca, 0x7a, 0x36, 0x5f, 0xe0, 0xa3,
0xe9, 0x73, 0xdd, 0x9e, 0x34, 0x4f, 0xfd, 0xb2, 0x6c, 0x15, 0x4a, 0x60, 0x21, 0xec, 0x5b, 0x28,
0xf2, 0x53, 0xe9, 0x64, 0xb7, 0x27, 0xcd, 0x51, 0xb7, 0x02, 0x86, 0x9b, 0x20, 0x35, 0xec, 0x61,
0xdc, 0xcd, 0xeb, 0xb7, 0x8c, 0x8a, 0xaa, 0x17, 0xf9, 0x58, 0x7a, 0xb9, 0xdb, 0x93, 0xf8, 0xc0,
0x37, 0xd8, 0x5b, 0xe9, 0xd8, 0xc3, 0x6f, 0x85, 0xc8, 0xa5, 0x9f, 0xa2, 0x60, 0x61, 0xf8, 0xd3,
0x06, 0x66, 0xc0, 0x85, 0x92, 0x56, 0x2c, 0x15, 0xcb, 0xd9, 0xdb, 0x46, 0x59, 0xcf, 0xea, 0x77,
0xca, 0x23, 0x09, 0xfb, 0xa9, 0x50, 0xe7, 0x82, 0xd5, 0x84, 0xd7, 0x81, 0x30, 0xea, 0x9f, 0x53,
0x4b, 0xc5, 0x72, 0x5e, 0x37, 0x4a, 0xaa, 0x96, 0x2f, 0xe6, 0x78, 0x2e, 0xbd, 0xda, 0xed, 0x49,
0x4b, 0x14, 0x32, 0x34, 0x54, 0xf0, 0x6d, 0xf0, 0x9f, 0x51, 0x70, 0xa5, 0xa8, 0xe7, 0x0b, 0xef,
0x05, 0xd8, 0x68, 0x7a, 0xa5, 0xdb, 0x93, 0x20, 0xc5, 0x56, 0x42, 0x13, 0x00, 0x2f, 0x83, 0x95,
0x51, 0x68, 0x29, 0x5b, 0x2e, 0xab, 0x39, 0x7e, 0x2a, 0xcd, 0x77, 0x7b, 0x52, 0x92, 0x62, 0x4a,
0xa6, 0xeb, 0xa2, 0x3a, 0xbc, 0x0a, 0x52, 0xa3, 0xde, 0x9a, 0xfa, 0xbe, 0xba, 0xad, 0xab, 0x39,
0x3e, 0x96, 0x86, 0xdd, 0x9e, 0xb4, 0x40, 0xfd, 0x35, 0xf4, 0x11, 0xaa, 0x11, 0x74, 0x2a, 0xff,
0xcd, 0x6c, 0xfe, 0xb6, 0x9a, 0xe3, 0xa7, 0xc3, 0xfc, 0x37, 0x4d, 0xab, 0x89, 0xea, 0xb4, 0x9c,
0x4a, 0xe1, 0xe0, 0x85, 0x10, 0x79, 0xf6, 0x42, 0x88, 0x7c, 0x7e, 0x28, 0x44, 0x0e, 0x0e, 0x05,
0xee, 0xe9, 0xa1, 0xc0, 0xfd, 0x7e, 0x28, 0x70, 0x8f, 0x5e, 0x0a, 0x91, 0xa7, 0x2f, 0x85, 0xc8,
0xb3, 0x97, 0x42, 0xe4, 0xfe, 0xdf, 0x2f, 0xc4, 0x3d, 0xff, 0x3f, 0x35, 0xbf, 0x9f, 0xab, 0x33,
0xfe, 0x0e, 0x79, 0xfd, 0xaf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xd7, 0x68, 0xea, 0xf2, 0xc4, 0x0d,
0x00, 0x00,
}
func (this *TextProposal) Equal(that interface{}) bool {
@ -667,6 +709,44 @@ func (this *TallyResult) Equal(that interface{}) bool {
}
return true
}
func (m *SubVote) 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 *SubVote) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *SubVote) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
{
size := m.Rate.Size()
i -= size
if _, err := m.Rate.MarshalTo(dAtA[i:]); err != nil {
return 0, err
}
i = encodeVarintGov(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x12
if m.Option != 0 {
i = encodeVarintGov(dAtA, i, uint64(m.Option))
i--
dAtA[i] = 0x8
}
return len(dAtA) - i, nil
}
func (m *TextProposal) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
@ -937,23 +1017,19 @@ func (m *Vote) MarshalToSizedBuffer(dAtA []byte) (int, error) {
_ = i
var l int
_ = l
if len(m.Options) > 0 {
dAtA8 := make([]byte, len(m.Options)*10)
var j7 int
for _, num := range m.Options {
for num >= 1<<7 {
dAtA8[j7] = uint8(uint64(num)&0x7f | 0x80)
num >>= 7
j7++
if len(m.SubVotes) > 0 {
for iNdEx := len(m.SubVotes) - 1; iNdEx >= 0; iNdEx-- {
{
size, err := m.SubVotes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintGov(dAtA, i, uint64(size))
}
dAtA8[j7] = uint8(num)
j7++
i--
dAtA[i] = 0x1a
}
i -= j7
copy(dAtA[i:], dAtA8[:j7])
i = encodeVarintGov(dAtA, i, uint64(j7))
i--
dAtA[i] = 0x1a
}
if len(m.Voter) > 0 {
i -= len(m.Voter)
@ -990,12 +1066,12 @@ func (m *DepositParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
_ = i
var l int
_ = l
n9, err9 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.MaxDepositPeriod, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.MaxDepositPeriod):])
if err9 != nil {
return 0, err9
n7, err7 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.MaxDepositPeriod, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.MaxDepositPeriod):])
if err7 != nil {
return 0, err7
}
i -= n9
i = encodeVarintGov(dAtA, i, uint64(n9))
i -= n7
i = encodeVarintGov(dAtA, i, uint64(n7))
i--
dAtA[i] = 0x12
if len(m.MinDeposit) > 0 {
@ -1035,12 +1111,12 @@ func (m *VotingParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
_ = i
var l int
_ = l
n10, err10 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.VotingPeriod, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.VotingPeriod):])
if err10 != nil {
return 0, err10
n8, err8 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.VotingPeriod, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.VotingPeriod):])
if err8 != nil {
return 0, err8
}
i -= n10
i = encodeVarintGov(dAtA, i, uint64(n10))
i -= n8
i = encodeVarintGov(dAtA, i, uint64(n8))
i--
dAtA[i] = 0xa
return len(dAtA) - i, nil
@ -1110,6 +1186,20 @@ func encodeVarintGov(dAtA []byte, offset int, v uint64) int {
dAtA[offset] = uint8(v)
return base
}
func (m *SubVote) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if m.Option != 0 {
n += 1 + sovGov(uint64(m.Option))
}
l = m.Rate.Size()
n += 1 + l + sovGov(uint64(l))
return n
}
func (m *TextProposal) Size() (n int) {
if m == nil {
return 0
@ -1214,12 +1304,11 @@ func (m *Vote) Size() (n int) {
if l > 0 {
n += 1 + l + sovGov(uint64(l))
}
if len(m.Options) > 0 {
l = 0
for _, e := range m.Options {
l += sovGov(uint64(e))
if len(m.SubVotes) > 0 {
for _, e := range m.SubVotes {
l = e.Size()
n += 1 + l + sovGov(uint64(l))
}
n += 1 + sovGov(uint64(l)) + l
}
return n
}
@ -1273,6 +1362,112 @@ func sovGov(x uint64) (n int) {
func sozGov(x uint64) (n int) {
return sovGov(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *SubVote) 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 ErrIntOverflowGov
}
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: SubVote: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: SubVote: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Option", wireType)
}
m.Option = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGov
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Option |= VoteOption(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Rate", 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
}
if err := m.Rate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipGov(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthGov
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthGov
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *TextProposal) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
@ -2124,74 +2319,39 @@ func (m *Vote) Unmarshal(dAtA []byte) error {
m.Voter = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 3:
if wireType == 0 {
var v VoteOption
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGov
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= VoteOption(b&0x7F) << shift
if b < 0x80 {
break
}
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field SubVotes", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGov
}
m.Options = append(m.Options, v)
} else if wireType == 2 {
var packedLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGov
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
packedLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if packedLen < 0 {
return ErrInvalidLengthGov
}
postIndex := iNdEx + packedLen
if postIndex < 0 {
return ErrInvalidLengthGov
}
if postIndex > l {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
var elementCount int
if elementCount != 0 && len(m.Options) == 0 {
m.Options = make([]VoteOption, 0, elementCount)
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
for iNdEx < postIndex {
var v VoteOption
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGov
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= VoteOption(b&0x7F) << shift
if b < 0x80 {
break
}
}
m.Options = append(m.Options, v)
}
} else {
return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType)
}
if msglen < 0 {
return ErrInvalidLengthGov
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthGov
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.SubVotes = append(m.SubVotes, SubVote{})
if err := m.SubVotes[len(m.SubVotes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipGov(dAtA[iNdEx:])

10
x/gov/types/msgs.go
View File

@ -177,8 +177,8 @@ func (msg MsgDeposit) GetSigners() []sdk.AccAddress {
// NewMsgVote creates a message to cast a vote on an active proposal
//nolint:interfacer
func NewMsgVote(voter sdk.AccAddress, proposalID uint64, option VoteOption) *MsgVote {
return &MsgVote{proposalID, voter.String(), option}
func NewMsgVote(voter sdk.AccAddress, proposalID uint64, subVotes []SubVote) *MsgVote {
return &MsgVote{proposalID, voter.String(), subVotes}
}
// Route implements Msg
@ -192,8 +192,10 @@ func (msg MsgVote) ValidateBasic() error {
if msg.Voter == "" {
return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, msg.Voter)
}
if !ValidVoteOption(msg.Option) {
return sdkerrors.Wrap(ErrInvalidVote, msg.Option.String())
for _, subvote := range msg.SubVotes {
if !ValidSubVote(subvote) {
return sdkerrors.Wrap(ErrInvalidVote, subvote.String())
}
}
return nil

130
x/gov/types/tx.pb.go
View File

@ -119,9 +119,9 @@ func (m *MsgSubmitProposalResponse) GetProposalId() uint64 {
// MsgVote defines a message to cast a vote.
type MsgVote struct {
ProposalId uint64 `protobuf:"varint,1,opt,name=proposal_id,json=proposalId,proto3" json:"proposal_id" yaml:"proposal_id"`
Voter string `protobuf:"bytes,2,opt,name=voter,proto3" json:"voter,omitempty"`
Option VoteOption `protobuf:"varint,3,opt,name=option,proto3,enum=cosmos.gov.v1beta1.VoteOption" json:"option,omitempty"`
ProposalId uint64 `protobuf:"varint,1,opt,name=proposal_id,json=proposalId,proto3" json:"proposal_id" yaml:"proposal_id"`
Voter string `protobuf:"bytes,2,opt,name=voter,proto3" json:"voter,omitempty"`
SubVotes []SubVote `protobuf:"bytes,3,rep,name=sub_votes,json=subVotes,proto3" json:"sub_votes"`
}
func (m *MsgVote) Reset() { *m = MsgVote{} }
@ -281,44 +281,45 @@ func init() {
func init() { proto.RegisterFile("cosmos/gov/v1beta1/tx.proto", fileDescriptor_3c053992595e3dce) }
var fileDescriptor_3c053992595e3dce = []byte{
// 586 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x54, 0xbf, 0x6f, 0xd3, 0x40,
0x14, 0xb6, 0x93, 0xd2, 0xd0, 0x8b, 0x94, 0xd2, 0x53, 0x84, 0x12, 0xb7, 0xb2, 0x23, 0xa3, 0xa2,
0x2c, 0xb1, 0x69, 0x90, 0x18, 0xca, 0x44, 0x8a, 0x10, 0x20, 0x45, 0x80, 0x91, 0x18, 0x58, 0x22,
0xdb, 0x71, 0x8d, 0x45, 0xe2, 0x67, 0xe5, 0x2e, 0x51, 0xb3, 0x31, 0x22, 0x06, 0x60, 0x64, 0xcc,
0xcc, 0x86, 0xc4, 0x1f, 0x51, 0x31, 0x75, 0x64, 0x40, 0x01, 0x25, 0x0b, 0x30, 0xf6, 0x2f, 0x40,
0xbe, 0x1f, 0x69, 0xd5, 0xa4, 0x01, 0xa4, 0x4e, 0xc9, 0x7b, 0xdf, 0xfb, 0x3e, 0xdd, 0xf7, 0xdd,
0xf3, 0xa1, 0x4d, 0x1f, 0x48, 0x17, 0x88, 0x1d, 0xc2, 0xc0, 0x1e, 0xec, 0x78, 0x01, 0x75, 0x77,
0x6c, 0x7a, 0x60, 0x25, 0x3d, 0xa0, 0x80, 0x31, 0x07, 0xad, 0x10, 0x06, 0x96, 0x00, 0x35, 0x5d,
0x10, 0x3c, 0x97, 0x04, 0x33, 0x86, 0x0f, 0x51, 0xcc, 0x39, 0xda, 0xd6, 0x02, 0xc1, 0x94, 0xcf,
0xd1, 0x32, 0x47, 0x5b, 0xac, 0xb2, 0x85, 0x3c, 0x87, 0x8a, 0x21, 0x84, 0xc0, 0xfb, 0xe9, 0x3f,
0x49, 0x08, 0x01, 0xc2, 0x4e, 0x60, 0xb3, 0xca, 0xeb, 0xef, 0xdb, 0x6e, 0x3c, 0xe4, 0x90, 0xf9,
0x2e, 0x83, 0x36, 0x9a, 0x24, 0x7c, 0xda, 0xf7, 0xba, 0x11, 0x7d, 0xdc, 0x83, 0x04, 0x88, 0xdb,
0xc1, 0xb7, 0x51, 0xce, 0x87, 0x98, 0x06, 0x31, 0x2d, 0xa9, 0x15, 0xb5, 0x9a, 0xaf, 0x17, 0x2d,
0x2e, 0x61, 0x49, 0x09, 0xeb, 0x4e, 0x3c, 0x6c, 0xe4, 0xbf, 0x7c, 0xae, 0xe5, 0xf6, 0xf8, 0xa0,
0x23, 0x19, 0xf8, 0xad, 0x8a, 0xd6, 0xa3, 0x38, 0xa2, 0x91, 0xdb, 0x69, 0xb5, 0x83, 0x04, 0x48,
0x44, 0x4b, 0x99, 0x4a, 0xb6, 0x9a, 0xaf, 0x97, 0x2d, 0x71, 0xd8, 0xd4, 0xb7, 0x0c, 0xc3, 0xda,
0x83, 0x28, 0x6e, 0x3c, 0x3c, 0x1c, 0x1b, 0xca, 0xf1, 0xd8, 0xb8, 0x3a, 0x74, 0xbb, 0x9d, 0x5d,
0xf3, 0x0c, 0xdf, 0xfc, 0xf8, 0xdd, 0xa8, 0x86, 0x11, 0x7d, 0xd1, 0xf7, 0x2c, 0x1f, 0xba, 0xc2,
0xb3, 0xf8, 0xa9, 0x91, 0xf6, 0x4b, 0x9b, 0x0e, 0x93, 0x80, 0x30, 0x29, 0xe2, 0x14, 0x04, 0xfb,
0x2e, 0x27, 0x63, 0x0d, 0x5d, 0x4e, 0x98, 0xb3, 0xa0, 0x57, 0xca, 0x56, 0xd4, 0xea, 0x9a, 0x33,
0xab, 0x77, 0xaf, 0xbc, 0x1e, 0x19, 0xca, 0x87, 0x91, 0xa1, 0xfc, 0x1c, 0x19, 0xca, 0xab, 0x6f,
0x15, 0xc5, 0xf4, 0x51, 0x79, 0x2e, 0x10, 0x27, 0x20, 0x09, 0xc4, 0x24, 0xc0, 0xf7, 0x50, 0x3e,
0x11, 0xbd, 0x56, 0xd4, 0x66, 0xe1, 0xac, 0x34, 0xb6, 0x7f, 0x8f, 0x8d, 0xd3, 0xed, 0xe3, 0xb1,
0x81, 0xb9, 0x8d, 0x53, 0x4d, 0xd3, 0x41, 0xb2, 0x7a, 0xd0, 0x36, 0x3f, 0xa9, 0x28, 0xd7, 0x24,
0xe1, 0x33, 0xa0, 0x17, 0xa6, 0x89, 0x8b, 0xe8, 0xd2, 0x00, 0x68, 0xd0, 0x2b, 0x65, 0x98, 0x47,
0x5e, 0xe0, 0x5b, 0x68, 0x15, 0x12, 0x1a, 0x41, 0xcc, 0xac, 0x17, 0xea, 0xba, 0x35, 0xbf, 0x8f,
0x56, 0x7a, 0x8e, 0x47, 0x6c, 0xca, 0x11, 0xd3, 0x0b, 0x82, 0xd9, 0x40, 0xeb, 0xe2, 0xc8, 0x32,
0x0e, 0xf3, 0x97, 0x8a, 0x50, 0x93, 0x84, 0x32, 0xe8, 0x8b, 0x72, 0xb2, 0x85, 0xd6, 0xc4, 0xc5,
0x83, 0x74, 0x73, 0xd2, 0xc0, 0x3e, 0x5a, 0x75, 0xbb, 0xd0, 0x8f, 0x69, 0x29, 0xfb, 0xb7, 0xad,
0xba, 0x91, 0x6e, 0xd5, 0x7f, 0xed, 0x8e, 0x90, 0x5e, 0x60, 0xbf, 0x88, 0xf0, 0x89, 0x55, 0x99,
0x40, 0xfd, 0x4d, 0x06, 0x65, 0x9b, 0x24, 0xc4, 0xfb, 0xa8, 0x70, 0xe6, 0x1b, 0xda, 0x5e, 0x14,
0xf4, 0xdc, 0x66, 0x69, 0xb5, 0x7f, 0x1a, 0x9b, 0x2d, 0xe0, 0x7d, 0xb4, 0xc2, 0x96, 0x66, 0xf3,
0x1c, 0x5a, 0x0a, 0x6a, 0xd7, 0x96, 0x80, 0x33, 0xa5, 0x27, 0x28, 0x27, 0xef, 0x4d, 0x3f, 0x67,
0x5e, 0xe0, 0xda, 0xf5, 0xe5, 0xb8, 0x94, 0x6c, 0x34, 0x0e, 0x27, 0xba, 0x7a, 0x34, 0xd1, 0xd5,
0x1f, 0x13, 0x5d, 0x7d, 0x3f, 0xd5, 0x95, 0xa3, 0xa9, 0xae, 0x7c, 0x9d, 0xea, 0xca, 0xf3, 0xe5,
0x17, 0x70, 0xc0, 0x1e, 0x3a, 0x76, 0x0d, 0xde, 0x2a, 0x7b, 0x61, 0x6e, 0xfe, 0x09, 0x00, 0x00,
0xff, 0xff, 0x7f, 0x09, 0x3f, 0x57, 0x54, 0x05, 0x00, 0x00,
// 593 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x54, 0x31, 0x6f, 0xd3, 0x40,
0x14, 0xb6, 0x93, 0xd2, 0xb4, 0x17, 0xa9, 0xa5, 0xa7, 0x08, 0x25, 0x4e, 0x65, 0x47, 0x46, 0x45,
0x59, 0x62, 0xd3, 0xb0, 0x15, 0x09, 0x09, 0x17, 0x21, 0x40, 0x8a, 0x04, 0xae, 0xc4, 0xc0, 0x12,
0xd9, 0x8e, 0x6b, 0x2c, 0x12, 0x3f, 0x2b, 0x77, 0x8e, 0x9a, 0x8d, 0x11, 0x31, 0x00, 0x23, 0x63,
0x66, 0x66, 0x16, 0xfe, 0x41, 0xc5, 0xd4, 0x91, 0x01, 0x05, 0x94, 0x2c, 0xc0, 0xd8, 0x5f, 0x80,
0xec, 0xbb, 0x4b, 0xab, 0x26, 0x8d, 0x40, 0xea, 0x94, 0xbc, 0xf7, 0xdd, 0xf7, 0xe9, 0xbe, 0xef,
0x3d, 0x1f, 0xaa, 0x7a, 0x40, 0x7a, 0x40, 0xcc, 0x00, 0x06, 0xe6, 0x60, 0xd7, 0xf5, 0xa9, 0xb3,
0x6b, 0xd2, 0x23, 0x23, 0xee, 0x03, 0x05, 0x8c, 0x19, 0x68, 0x04, 0x30, 0x30, 0x38, 0xa8, 0xa8,
0x9c, 0xe0, 0x3a, 0xc4, 0x9f, 0x31, 0x3c, 0x08, 0x23, 0xc6, 0x51, 0xb6, 0x17, 0x08, 0xa6, 0x7c,
0x86, 0x56, 0x18, 0xda, 0xce, 0x2a, 0x93, 0xcb, 0x33, 0xa8, 0x14, 0x40, 0x00, 0xac, 0x9f, 0xfe,
0x13, 0x84, 0x00, 0x20, 0xe8, 0xfa, 0x66, 0x56, 0xb9, 0xc9, 0xa1, 0xe9, 0x44, 0x43, 0x06, 0xe9,
0xef, 0x73, 0x68, 0xab, 0x45, 0x82, 0x83, 0xc4, 0xed, 0x85, 0xf4, 0x69, 0x1f, 0x62, 0x20, 0x4e,
0x17, 0xdf, 0x45, 0x05, 0x0f, 0x22, 0xea, 0x47, 0xb4, 0x2c, 0xd7, 0xe4, 0x7a, 0xb1, 0x59, 0x32,
0x98, 0x84, 0x21, 0x24, 0x8c, 0xfb, 0xd1, 0xd0, 0x2a, 0x7e, 0xfd, 0xdc, 0x28, 0xec, 0xb3, 0x83,
0xb6, 0x60, 0xe0, 0x77, 0x32, 0xda, 0x0c, 0xa3, 0x90, 0x86, 0x4e, 0xb7, 0xdd, 0xf1, 0x63, 0x20,
0x21, 0x2d, 0xe7, 0x6a, 0xf9, 0x7a, 0xb1, 0x59, 0x31, 0xf8, 0x65, 0x53, 0xdf, 0x22, 0x0c, 0x63,
0x1f, 0xc2, 0xc8, 0x7a, 0x72, 0x3c, 0xd6, 0xa4, 0xd3, 0xb1, 0x76, 0x63, 0xe8, 0xf4, 0xba, 0x7b,
0xfa, 0x05, 0xbe, 0xfe, 0xe9, 0x87, 0x56, 0x0f, 0x42, 0xfa, 0x32, 0x71, 0x0d, 0x0f, 0x7a, 0xdc,
0x33, 0xff, 0x69, 0x90, 0xce, 0x2b, 0x93, 0x0e, 0x63, 0x9f, 0x64, 0x52, 0xc4, 0xde, 0xe0, 0xec,
0x07, 0x8c, 0x8c, 0x15, 0xb4, 0x16, 0x67, 0xce, 0xfc, 0x7e, 0x39, 0x5f, 0x93, 0xeb, 0xeb, 0xf6,
0xac, 0xde, 0xbb, 0xfe, 0x66, 0xa4, 0x49, 0x1f, 0x47, 0x9a, 0xf4, 0x6b, 0xa4, 0x49, 0xaf, 0xbf,
0xd7, 0x24, 0xdd, 0x43, 0x95, 0xb9, 0x40, 0x6c, 0x9f, 0xc4, 0x10, 0x11, 0x1f, 0x3f, 0x44, 0xc5,
0x98, 0xf7, 0xda, 0x61, 0x27, 0x0b, 0x67, 0xc5, 0xda, 0xf9, 0x33, 0xd6, 0xce, 0xb7, 0x4f, 0xc7,
0x1a, 0x66, 0x36, 0xce, 0x35, 0x75, 0x1b, 0x89, 0xea, 0x71, 0x47, 0xff, 0x22, 0xa3, 0x42, 0x8b,
0x04, 0xcf, 0x81, 0x5e, 0x99, 0x26, 0x2e, 0xa1, 0x6b, 0x03, 0xa0, 0x7e, 0xbf, 0x9c, 0xcb, 0x3c,
0xb2, 0x02, 0xdf, 0x43, 0xeb, 0x24, 0x71, 0xdb, 0x69, 0x41, 0xca, 0xf9, 0x6c, 0x0c, 0x55, 0x63,
0x7e, 0x25, 0x8d, 0x83, 0xc4, 0x4d, 0x6f, 0x63, 0xad, 0xa4, 0x83, 0xb0, 0xd7, 0x08, 0x2b, 0xc9,
0x82, 0x80, 0xb6, 0xd0, 0x26, 0xbf, 0xba, 0x88, 0x45, 0xff, 0x2d, 0x23, 0xd4, 0x22, 0x81, 0x08,
0xfc, 0xaa, 0x1c, 0x6d, 0xa3, 0x75, 0xbe, 0x00, 0x20, 0x5c, 0x9d, 0x35, 0xb0, 0x87, 0x56, 0x9d,
0x1e, 0x24, 0x11, 0xe5, 0xb6, 0x96, 0x6c, 0xd7, 0xed, 0xd4, 0xd4, 0x7f, 0xed, 0x10, 0x97, 0x5e,
0x60, 0xbf, 0x84, 0xf0, 0x99, 0x55, 0x91, 0x40, 0xf3, 0x6d, 0x0e, 0xe5, 0x5b, 0x24, 0xc0, 0x87,
0x68, 0xe3, 0xc2, 0xb7, 0xb4, 0xb3, 0x28, 0xed, 0xb9, 0x0d, 0x53, 0x1a, 0xff, 0x74, 0x6c, 0xb6,
0x88, 0x8f, 0xd0, 0x4a, 0xb6, 0x3c, 0xd5, 0x4b, 0x68, 0x29, 0xa8, 0xdc, 0x5c, 0x02, 0xce, 0x94,
0x9e, 0xa1, 0x82, 0x98, 0x9b, 0x7a, 0xc9, 0x79, 0x8e, 0x2b, 0xb7, 0x96, 0xe3, 0x42, 0xd2, 0xb2,
0x8e, 0x27, 0xaa, 0x7c, 0x32, 0x51, 0xe5, 0x9f, 0x13, 0x55, 0xfe, 0x30, 0x55, 0xa5, 0x93, 0xa9,
0x2a, 0x7d, 0x9b, 0xaa, 0xd2, 0x8b, 0xe5, 0x03, 0x38, 0xca, 0x1e, 0xbc, 0x6c, 0x0c, 0xee, 0x6a,
0xf6, 0xd2, 0xdc, 0xf9, 0x1b, 0x00, 0x00, 0xff, 0xff, 0x7e, 0x2c, 0x84, 0x48, 0x5c, 0x05, 0x00,
0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@ -583,10 +584,19 @@ func (m *MsgVote) MarshalToSizedBuffer(dAtA []byte) (int, error) {
_ = i
var l int
_ = l
if m.Option != 0 {
i = encodeVarintTx(dAtA, i, uint64(m.Option))
i--
dAtA[i] = 0x18
if len(m.SubVotes) > 0 {
for iNdEx := len(m.SubVotes) - 1; iNdEx >= 0; iNdEx-- {
{
size, err := m.SubVotes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintTx(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x1a
}
}
if len(m.Voter) > 0 {
i -= len(m.Voter)
@ -757,8 +767,11 @@ func (m *MsgVote) Size() (n int) {
if l > 0 {
n += 1 + l + sovTx(uint64(l))
}
if m.Option != 0 {
n += 1 + sovTx(uint64(m.Option))
if len(m.SubVotes) > 0 {
for _, e := range m.SubVotes {
l = e.Size()
n += 1 + l + sovTx(uint64(l))
}
}
return n
}
@ -1117,10 +1130,10 @@ func (m *MsgVote) Unmarshal(dAtA []byte) error {
m.Voter = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 3:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Option", wireType)
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field SubVotes", wireType)
}
m.Option = 0
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTx
@ -1130,11 +1143,26 @@ func (m *MsgVote) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
m.Option |= VoteOption(b&0x7F) << shift
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
}
m.SubVotes = append(m.SubVotes, SubVote{})
if err := m.SubVotes[len(m.SubVotes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipTx(dAtA[iNdEx:])

26
x/gov/types/vote.go
View File

@ -1,6 +1,7 @@
package types
import (
"encoding/json"
"fmt"
yaml "gopkg.in/yaml.v2"
@ -10,8 +11,8 @@ import (
// NewVote creates a new Vote instance
//nolint:interfacer
func NewVote(proposalID uint64, voter sdk.AccAddress, option VoteOption) Vote {
return Vote{proposalID, voter.String(), option}
func NewVote(proposalID uint64, voter sdk.AccAddress, subvotes []SubVote) Vote {
return Vote{proposalID, voter.String(), subvotes}
}
func (v Vote) String() string {
@ -43,7 +44,7 @@ func (v Votes) String() string {
}
out := fmt.Sprintf("Votes for Proposal %d:", v[0].ProposalId)
for _, vot := range v {
out += fmt.Sprintf("\n %s: %s", vot.Voter, vot.Option)
out += fmt.Sprintf("\n %s: %s", vot.Voter, vot.SubVotes)
}
return out
}
@ -53,6 +54,25 @@ func (v Vote) Empty() bool {
return v.String() == Vote{}.String()
}
// NewSubVote creates a new Vote instance
//nolint:interfacer
func NewSubVote(option VoteOption, rate int64) SubVote {
return SubVote{option, sdk.NewDec(rate)}
}
func (v SubVote) String() string {
out, _ := json.Marshal(v)
return string(out)
}
// ValidSubVote returns true if the sub vote is valid and false otherwise.
func ValidSubVote(subvote SubVote) bool {
if !subvote.Rate.IsPositive() {
return false
}
return ValidVoteOption(subvote.Option)
}
// VoteOptionFromString returns a VoteOption from a string. It returns an error
// if the string is invalid.
func VoteOptionFromString(str string) (VoteOption, error) {