codec.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: x/gov/codec.proto

package gov

import (
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	github_com_iov_one_weave "github.com/iov-one/weave"
	io "io"
	math "math"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package

// VoteOptions define possible values for a vote including the INVALID default.
type VoteOption int32

const (
	VoteOption_Invalid VoteOption = 0
	VoteOption_Yes     VoteOption = 1
	VoteOption_No      VoteOption = 2
	VoteOption_Abstain VoteOption = 3
)

var VoteOption_name = map[int32]string{
	0: "VOTE_OPTION_INVALID",
	1: "VOTE_OPTION_YES",
	2: "VOTE_OPTION_NO",
	3: "VOTE_OPTION_ABSTAIN",
}

var VoteOption_value = map[string]int32{
	"VOTE_OPTION_INVALID": 0,
	"VOTE_OPTION_YES":     1,
	"VOTE_OPTION_NO":      2,
	"VOTE_OPTION_ABSTAIN": 3,
}

func (x VoteOption) String() string {
	return proto.EnumName(VoteOption_name, int32(x))
}

func (VoteOption) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_24f6e3c5f1b82a85, []int{0}
}

// Status of the proposal base on the final tally result. `UNDEFINED` as initial value.
type TextProposal_Status int32

const (
	TextProposal_Invalid   TextProposal_Status = 0
	TextProposal_Undefined TextProposal_Status = 1
	TextProposal_Accepted  TextProposal_Status = 2
	TextProposal_Rejected  TextProposal_Status = 3
)

var TextProposal_Status_name = map[int32]string{
	0: "TEXT_PROPOSAL_STATUS_INVALID",
	1: "TEXT_PROPOSAL_STATUS_UNDEFINED",
	2: "TEXT_PROPOSAL_STATUS_ACCEPTED",
	3: "TEXT_PROPOSAL_STATUS_REJECTED",
}

var TextProposal_Status_value = map[string]int32{
	"TEXT_PROPOSAL_STATUS_INVALID":   0,
	"TEXT_PROPOSAL_STATUS_UNDEFINED": 1,
	"TEXT_PROPOSAL_STATUS_ACCEPTED":  2,
	"TEXT_PROPOSAL_STATUS_REJECTED":  3,
}

func (x TextProposal_Status) String() string {
	return proto.EnumName(TextProposal_Status_name, int32(x))
}

func (TextProposal_Status) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_24f6e3c5f1b82a85, []int{4, 0}
}

// Electorate defines who may vote in an election. This same group can be used in many elections
// and is stored for re-use
type Electorate struct {
	// Human readable title.
	Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"`
	// Elector defines a list of all signatures that are allowed to participate in a vote
	Electors []Elector `protobuf:"bytes,2,rep,name=electors,proto3" json:"electors"`
	// TotalWeightElectorate is the sum of all electors weights.
	TotalWeightElectorate uint64 `protobuf:"varint,3,opt,name=TotalWeightElectorate,proto3" json:"TotalWeightElectorate,omitempty"`
}

func (m *Electorate) Reset()         { *m = Electorate{} }
func (m *Electorate) String() string { return proto.CompactTextString(m) }
func (*Electorate) ProtoMessage()    {}
func (*Electorate) Descriptor() ([]byte, []int) {
	return fileDescriptor_24f6e3c5f1b82a85, []int{0}
}
func (m *Electorate) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Electorate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Electorate.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Electorate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Electorate.Merge(m, src)
}
func (m *Electorate) XXX_Size() int {
	return m.Size()
}
func (m *Electorate) XXX_DiscardUnknown() {
	xxx_messageInfo_Electorate.DiscardUnknown(m)
}

var xxx_messageInfo_Electorate proto.InternalMessageInfo

func (m *Electorate) GetTitle() string {
	if m != nil {
		return m.Title
	}
	return ""
}

func (m *Electorate) GetElectors() []Elector {
	if m != nil {
		return m.Electors
	}
	return nil
}

func (m *Electorate) GetTotalWeightElectorate() uint64 {
	if m != nil {
		return m.TotalWeightElectorate
	}
	return 0
}

// Elector clubs together a signature with a weight. The greater the weight
// the greater the power of a participant.
type Elector struct {
	// The address of the voter.
	Signature github_com_iov_one_weave.Address `protobuf:"bytes,1,opt,name=signature,proto3,casttype=github.com/iov-one/weave.Address" json:"signature,omitempty"`
	// Weight defines the power of the participants vote. max value is 65535 (2^16-1).
	Weight uint32 `protobuf:"varint,2,opt,name=weight,proto3" json:"weight,omitempty"`
}

func (m *Elector) Reset()         { *m = Elector{} }
func (m *Elector) String() string { return proto.CompactTextString(m) }
func (*Elector) ProtoMessage()    {}
func (*Elector) Descriptor() ([]byte, []int) {
	return fileDescriptor_24f6e3c5f1b82a85, []int{1}
}
func (m *Elector) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Elector) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Elector.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Elector) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Elector.Merge(m, src)
}
func (m *Elector) XXX_Size() int {
	return m.Size()
}
func (m *Elector) XXX_DiscardUnknown() {
	xxx_messageInfo_Elector.DiscardUnknown(m)
}

var xxx_messageInfo_Elector proto.InternalMessageInfo

func (m *Elector) GetSignature() github_com_iov_one_weave.Address {
	if m != nil {
		return m.Signature
	}
	return nil
}

func (m *Elector) GetWeight() uint32 {
	if m != nil {
		return m.Weight
	}
	return 0
}

// Election Rule defines how an election is run. A proposal must be voted upon via a pre-defined ruleset.
type ElectionRule struct {
	// Human readable title.
	Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"`
	// Duration how long the voting period will take place.
	VotingPeriodHours uint32 `protobuf:"varint,3,opt,name=voting_period_hours,json=votingPeriodHours,proto3" json:"voting_period_hours,omitempty"`
	// Threshold is the fraction of all eligible voters, not only the ones who voted. To accept a
	// proposal this value must be exceeded.
	// The formula is `(yes*denominator) > (numerator*total_electors_weight)`.
	// The valid range for the threshold value is `0.5` to `1` (inclusive) which allows any value between half and all
	// of the eligible voters.
	Threshold Fraction `protobuf:"bytes,4,opt,name=threshold,proto3" json:"threshold"`
}

func (m *ElectionRule) Reset()         { *m = ElectionRule{} }
func (m *ElectionRule) String() string { return proto.CompactTextString(m) }
func (*ElectionRule) ProtoMessage()    {}
func (*ElectionRule) Descriptor() ([]byte, []int) {
	return fileDescriptor_24f6e3c5f1b82a85, []int{2}
}
func (m *ElectionRule) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ElectionRule) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ElectionRule.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ElectionRule) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ElectionRule.Merge(m, src)
}
func (m *ElectionRule) XXX_Size() int {
	return m.Size()
}
func (m *ElectionRule) XXX_DiscardUnknown() {
	xxx_messageInfo_ElectionRule.DiscardUnknown(m)
}

var xxx_messageInfo_ElectionRule proto.InternalMessageInfo

func (m *ElectionRule) GetTitle() string {
	if m != nil {
		return m.Title
	}
	return ""
}

func (m *ElectionRule) GetVotingPeriodHours() uint32 {
	if m != nil {
		return m.VotingPeriodHours
	}
	return 0
}

func (m *ElectionRule) GetThreshold() Fraction {
	if m != nil {
		return m.Threshold
	}
	return Fraction{}
}

// The Fraction type represents a numerator and denominator to enable higher precision thresholds in
// the election rules. For example:
// numerator: 1, denominator: 2 => > 50%
// numerator: 2, denominator: 3 => > 66.666..%
// numerator: 6273, denominator: 10000 => > 62.73%
// Valid range of the fraction is 0.5 to 1.
type Fraction struct {
	// The top number in a fraction.
	Numerator uint32 `protobuf:"varint,1,opt,name=numerator,proto3" json:"numerator,omitempty"`
	// The bottom number
	Denominator uint32 `protobuf:"varint,2,opt,name=denominator,proto3" json:"denominator,omitempty"`
}

func (m *Fraction) Reset()         { *m = Fraction{} }
func (m *Fraction) String() string { return proto.CompactTextString(m) }
func (*Fraction) ProtoMessage()    {}
func (*Fraction) Descriptor() ([]byte, []int) {
	return fileDescriptor_24f6e3c5f1b82a85, []int{3}
}
func (m *Fraction) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Fraction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Fraction.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Fraction) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Fraction.Merge(m, src)
}
func (m *Fraction) XXX_Size() int {
	return m.Size()
}
func (m *Fraction) XXX_DiscardUnknown() {
	xxx_messageInfo_Fraction.DiscardUnknown(m)
}

var xxx_messageInfo_Fraction proto.InternalMessageInfo

func (m *Fraction) GetNumerator() uint32 {
	if m != nil {
		return m.Numerator
	}
	return 0
}

func (m *Fraction) GetDenominator() uint32 {
	if m != nil {
		return m.Denominator
	}
	return 0
}

// A text form proposal for an on-chain governance process.
type TextProposal struct {
	// Human readable title.
	Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"`
	// Description of the proposal in text form.
	Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
	// Reference to the election rule
	ElectionRuleID []byte `protobuf:"bytes,3,opt,name=election_rule_id,json=electionRuleId,proto3" json:"election_rule_id,omitempty"`
	// Reference to the electorate to define the group of possible voters.
	ElectorateID []byte `protobuf:"bytes,4,opt,name=electorate_id,json=electorateId,proto3" json:"electorate_id,omitempty"`
	// Unix timestamp of the block where the voting period starts. Header time of the votes must be greater than or equal
	// to this start time.
	VotingStartTime github_com_iov_one_weave.UnixTime `protobuf:"varint,5,opt,name=voting_start_time,json=votingStartTime,proto3,casttype=github.com/iov-one/weave.UnixTime" json:"voting_start_time,omitempty"`
	// Unix timestamp of the block where the voting period ends. Header times of the votes must be before this end time
	// to be included in the election.
	VotingEndTime github_com_iov_one_weave.UnixTime `protobuf:"varint,6,opt,name=voting_end_time,json=votingEndTime,proto3,casttype=github.com/iov-one/weave.UnixTime" json:"voting_end_time,omitempty"`
	// Unix timestamp of the block where the proposal was added to the chain.
	SubmissionTime github_com_iov_one_weave.UnixTime `protobuf:"varint,7,opt,name=submission_time,json=submissionTime,proto3,casttype=github.com/iov-one/weave.UnixTime" json:"submission_time,omitempty"`
	// Address of the author who created the proposal. If not set explicit on creation it will default to the main signer.
	Author github_com_iov_one_weave.Address `protobuf:"bytes,8,opt,name=author,proto3,casttype=github.com/iov-one/weave.Address" json:"author,omitempty"`
	// Votes contain the list of individual votes with elector and voted option.
	Votes []*Vote `protobuf:"bytes,9,rep,name=votes,proto3" json:"votes,omitempty"`
	// Result of the election. Contains intermediate tally results while voting period is open.
	VoteResult TallyResult `protobuf:"bytes,10,opt,name=vote_result,json=voteResult,proto3" json:"vote_result"`
	// status is the final result based on the votes and election rule.
	Status TextProposal_Status `protobuf:"varint,11,opt,name=status,proto3,enum=gov.TextProposal_Status" json:"status,omitempty"`
}

func (m *TextProposal) Reset()         { *m = TextProposal{} }
func (m *TextProposal) String() string { return proto.CompactTextString(m) }
func (*TextProposal) ProtoMessage()    {}
func (*TextProposal) Descriptor() ([]byte, []int) {
	return fileDescriptor_24f6e3c5f1b82a85, []int{4}
}
func (m *TextProposal) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TextProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TextProposal.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TextProposal) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TextProposal.Merge(m, src)
}
func (m *TextProposal) XXX_Size() int {
	return m.Size()
}
func (m *TextProposal) XXX_DiscardUnknown() {
	xxx_messageInfo_TextProposal.DiscardUnknown(m)
}

var xxx_messageInfo_TextProposal proto.InternalMessageInfo

func (m *TextProposal) GetTitle() string {
	if m != nil {
		return m.Title
	}
	return ""
}

func (m *TextProposal) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

func (m *TextProposal) GetElectionRuleID() []byte {
	if m != nil {
		return m.ElectionRuleID
	}
	return nil
}

func (m *TextProposal) GetElectorateID() []byte {
	if m != nil {
		return m.ElectorateID
	}
	return nil
}

func (m *TextProposal) GetVotingStartTime() github_com_iov_one_weave.UnixTime {
	if m != nil {
		return m.VotingStartTime
	}
	return 0
}

func (m *TextProposal) GetVotingEndTime() github_com_iov_one_weave.UnixTime {
	if m != nil {
		return m.VotingEndTime
	}
	return 0
}

func (m *TextProposal) GetSubmissionTime() github_com_iov_one_weave.UnixTime {
	if m != nil {
		return m.SubmissionTime
	}
	return 0
}

func (m *TextProposal) GetAuthor() github_com_iov_one_weave.Address {
	if m != nil {
		return m.Author
	}
	return nil
}

func (m *TextProposal) GetVotes() []*Vote {
	if m != nil {
		return m.Votes
	}
	return nil
}

func (m *TextProposal) GetVoteResult() TallyResult {
	if m != nil {
		return m.VoteResult
	}
	return TallyResult{}
}

func (m *TextProposal) GetStatus() TextProposal_Status {
	if m != nil {
		return m.Status
	}
	return TextProposal_Invalid
}

// TallyResult contains sums of the votes and all data for the final result.
type TallyResult struct {
	// Sum of weights of all the voters that approved the proposal
	TotalYes uint32 `protobuf:"varint,1,opt,name=total_yes,json=totalYes,proto3" json:"total_yes,omitempty"`
	// Sum of weights of all the voters that rejected the proposal
	TotalNo uint32 `protobuf:"varint,2,opt,name=total_no,json=totalNo,proto3" json:"total_no,omitempty"`
	// Sum of weights of all the voters that voted abstain
	TotalAbstain uint32 `protobuf:"varint,3,opt,name=total_abstain,json=totalAbstain,proto3" json:"total_abstain,omitempty"`
	// Sum of all weights in the electorate.
	TotalWeightElectorate uint64 `protobuf:"varint,4,opt,name=total_weight_electorate,json=totalWeightElectorate,proto3" json:"total_weight_electorate,omitempty"`
	// Threshold is the fraction of all eligible voters, not only the ones who voted. To accept a
	// proposal this value must be exceeded.
	Threshold Fraction `protobuf:"bytes,5,opt,name=threshold,proto3" json:"threshold"`
}

func (m *TallyResult) Reset()         { *m = TallyResult{} }
func (m *TallyResult) String() string { return proto.CompactTextString(m) }
func (*TallyResult) ProtoMessage()    {}
func (*TallyResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_24f6e3c5f1b82a85, []int{5}
}
func (m *TallyResult) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TallyResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TallyResult.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TallyResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TallyResult.Merge(m, src)
}
func (m *TallyResult) XXX_Size() int {
	return m.Size()
}
func (m *TallyResult) XXX_DiscardUnknown() {
	xxx_messageInfo_TallyResult.DiscardUnknown(m)
}

var xxx_messageInfo_TallyResult proto.InternalMessageInfo

func (m *TallyResult) GetTotalYes() uint32 {
	if m != nil {
		return m.TotalYes
	}
	return 0
}

func (m *TallyResult) GetTotalNo() uint32 {
	if m != nil {
		return m.TotalNo
	}
	return 0
}

func (m *TallyResult) GetTotalAbstain() uint32 {
	if m != nil {
		return m.TotalAbstain
	}
	return 0
}

func (m *TallyResult) GetTotalWeightElectorate() uint64 {
	if m != nil {
		return m.TotalWeightElectorate
	}
	return 0
}

func (m *TallyResult) GetThreshold() Fraction {
	if m != nil {
		return m.Threshold
	}
	return Fraction{}
}

// Vote combines the elector and his voted option to archive them.
type Vote struct {
	Elector Elector    `protobuf:"bytes,1,opt,name=elector,proto3" json:"elector"`
	Voted   VoteOption `protobuf:"varint,2,opt,name=voted,proto3,enum=gov.VoteOption" json:"voted,omitempty"`
}

func (m *Vote) Reset()         { *m = Vote{} }
func (m *Vote) String() string { return proto.CompactTextString(m) }
func (*Vote) ProtoMessage()    {}
func (*Vote) Descriptor() ([]byte, []int) {
	return fileDescriptor_24f6e3c5f1b82a85, []int{6}
}
func (m *Vote) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Vote) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Vote.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Vote) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Vote.Merge(m, src)
}
func (m *Vote) XXX_Size() int {
	return m.Size()
}
func (m *Vote) XXX_DiscardUnknown() {
	xxx_messageInfo_Vote.DiscardUnknown(m)
}

var xxx_messageInfo_Vote proto.InternalMessageInfo

func (m *Vote) GetElector() Elector {
	if m != nil {
		return m.Elector
	}
	return Elector{}
}

func (m *Vote) GetVoted() VoteOption {
	if m != nil {
		return m.Voted
	}
	return VoteOption_Invalid
}

// CreateTextProposalMsg creates a new governance proposal.
type CreateTextProposalMsg struct {
	// Human readable title. Must match `^[a-zA-Z0-9 _.-]{4,128}$`
	Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"`
	// Human readable description with 3 to 5000 chars.
	Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
	// Reference to the election rule
	ElectionRuleID []byte `protobuf:"bytes,3,opt,name=election_rule_id,json=electionRuleId,proto3" json:"election_rule_id,omitempty"`
	// Reference to the electorate to define the group of possible voters.
	ElectorateID []byte `protobuf:"bytes,4,opt,name=electorate_id,json=electorateId,proto3" json:"electorate_id,omitempty"`
	// Unix timestamp when the proposal starts. Must be in the future.
	StartTime github_com_iov_one_weave.UnixTime `protobuf:"varint,5,opt,name=start_time,json=startTime,proto3,casttype=github.com/iov-one/weave.UnixTime" json:"start_time,omitempty"`
	// Author is an optional field to set the address of the author with a proposal. The author must sign the message.
	// When not set it will default to the main signer.
	Author github_com_iov_one_weave.Address `protobuf:"bytes,8,opt,name=author,proto3,casttype=github.com/iov-one/weave.Address" json:"author,omitempty"`
}

func (m *CreateTextProposalMsg) Reset()         { *m = CreateTextProposalMsg{} }
func (m *CreateTextProposalMsg) String() string { return proto.CompactTextString(m) }
func (*CreateTextProposalMsg) ProtoMessage()    {}
func (*CreateTextProposalMsg) Descriptor() ([]byte, []int) {
	return fileDescriptor_24f6e3c5f1b82a85, []int{7}
}
func (m *CreateTextProposalMsg) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CreateTextProposalMsg) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CreateTextProposalMsg.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CreateTextProposalMsg) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CreateTextProposalMsg.Merge(m, src)
}
func (m *CreateTextProposalMsg) XXX_Size() int {
	return m.Size()
}
func (m *CreateTextProposalMsg) XXX_DiscardUnknown() {
	xxx_messageInfo_CreateTextProposalMsg.DiscardUnknown(m)
}

var xxx_messageInfo_CreateTextProposalMsg proto.InternalMessageInfo

func (m *CreateTextProposalMsg) GetTitle() string {
	if m != nil {
		return m.Title
	}
	return ""
}

func (m *CreateTextProposalMsg) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

func (m *CreateTextProposalMsg) GetElectionRuleID() []byte {
	if m != nil {
		return m.ElectionRuleID
	}
	return nil
}

func (m *CreateTextProposalMsg) GetElectorateID() []byte {
	if m != nil {
		return m.ElectorateID
	}
	return nil
}

func (m *CreateTextProposalMsg) GetStartTime() github_com_iov_one_weave.UnixTime {
	if m != nil {
		return m.StartTime
	}
	return 0
}

func (m *CreateTextProposalMsg) GetAuthor() github_com_iov_one_weave.Address {
	if m != nil {
		return m.Author
	}
	return nil
}

// VoteMsg is the way to express a voice and participate in an election of a proposal on chain.
type VoteMsg struct {
	// The unique id of the proposal.
	ProposalID []byte `protobuf:"bytes,1,opt,name=proposal_id,json=proposalId,proto3" json:"proposal_id,omitempty"`
	// voter address is an optional field. When not set the main signer will be used as default. The voter address
	// must be included in the electorate for a valid vote.
	Voter github_com_iov_one_weave.Address `protobuf:"bytes,2,opt,name=voter,proto3,casttype=github.com/iov-one/weave.Address" json:"voter,omitempty"`
	// Option for the vote. Must be Yes, No or Abstain for a valid vote.
	Selected VoteOption `protobuf:"varint,3,opt,name=selected,proto3,enum=gov.VoteOption" json:"selected,omitempty"`
}

func (m *VoteMsg) Reset()         { *m = VoteMsg{} }
func (m *VoteMsg) String() string { return proto.CompactTextString(m) }
func (*VoteMsg) ProtoMessage()    {}
func (*VoteMsg) Descriptor() ([]byte, []int) {
	return fileDescriptor_24f6e3c5f1b82a85, []int{8}
}
func (m *VoteMsg) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *VoteMsg) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_VoteMsg.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *VoteMsg) XXX_Merge(src proto.Message) {
	xxx_messageInfo_VoteMsg.Merge(m, src)
}
func (m *VoteMsg) XXX_Size() int {
	return m.Size()
}
func (m *VoteMsg) XXX_DiscardUnknown() {
	xxx_messageInfo_VoteMsg.DiscardUnknown(m)
}

var xxx_messageInfo_VoteMsg proto.InternalMessageInfo

func (m *VoteMsg) GetProposalID() []byte {
	if m != nil {
		return m.ProposalID
	}
	return nil
}

func (m *VoteMsg) GetVoter() github_com_iov_one_weave.Address {
	if m != nil {
		return m.Voter
	}
	return nil
}

func (m *VoteMsg) GetSelected() VoteOption {
	if m != nil {
		return m.Selected
	}
	return VoteOption_Invalid
}

// TallyMsg can be sent after the voting period has ended to do the final tally and trigger any state changes.
// A final tally can be execute only once. A second submission will fail with an invalid state error.
type TallyMsg struct {
	// ProposalID is UUID of the proposal to close.
	ProposalID []byte `protobuf:"bytes,1,opt,name=proposal_id,json=proposalId,proto3" json:"proposal_id,omitempty"`
}

func (m *TallyMsg) Reset()         { *m = TallyMsg{} }
func (m *TallyMsg) String() string { return proto.CompactTextString(m) }
func (*TallyMsg) ProtoMessage()    {}
func (*TallyMsg) Descriptor() ([]byte, []int) {
	return fileDescriptor_24f6e3c5f1b82a85, []int{9}
}
func (m *TallyMsg) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TallyMsg) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TallyMsg.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TallyMsg) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TallyMsg.Merge(m, src)
}
func (m *TallyMsg) XXX_Size() int {
	return m.Size()
}
func (m *TallyMsg) XXX_DiscardUnknown() {
	xxx_messageInfo_TallyMsg.DiscardUnknown(m)
}

var xxx_messageInfo_TallyMsg proto.InternalMessageInfo

func (m *TallyMsg) GetProposalID() []byte {
	if m != nil {
		return m.ProposalID
	}
	return nil
}

func init() {
	proto.RegisterEnum("gov.VoteOption", VoteOption_name, VoteOption_value)
	proto.RegisterEnum("gov.TextProposal_Status", TextProposal_Status_name, TextProposal_Status_value)
	proto.RegisterType((*Electorate)(nil), "gov.Electorate")
	proto.RegisterType((*Elector)(nil), "gov.Elector")
	proto.RegisterType((*ElectionRule)(nil), "gov.ElectionRule")
	proto.RegisterType((*Fraction)(nil), "gov.Fraction")
	proto.RegisterType((*TextProposal)(nil), "gov.TextProposal")
	proto.RegisterType((*TallyResult)(nil), "gov.TallyResult")
	proto.RegisterType((*Vote)(nil), "gov.Vote")
	proto.RegisterType((*CreateTextProposalMsg)(nil), "gov.CreateTextProposalMsg")
	proto.RegisterType((*VoteMsg)(nil), "gov.VoteMsg")
	proto.RegisterType((*TallyMsg)(nil), "gov.TallyMsg")
}

func init() { proto.RegisterFile("x/gov/codec.proto", fileDescriptor_24f6e3c5f1b82a85) }

var fileDescriptor_24f6e3c5f1b82a85 = []byte{
	// 1043 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x56, 0x4d, 0x6f, 0xdb, 0x46,
	0x13, 0x36, 0x25, 0x59, 0x1f, 0xa3, 0x0f, 0x2b, 0x9b, 0xd7, 0x6f, 0x59, 0xd5, 0x95, 0x58, 0x35,
	0x01, 0x84, 0xb6, 0x96, 0x1a, 0xf7, 0x0b, 0x68, 0x73, 0x91, 0x2c, 0x06, 0x65, 0x90, 0x48, 0x2a,
	0x45, 0xbb, 0x0d, 0x7a, 0x20, 0x68, 0x71, 0x23, 0xb1, 0xa0, 0xb8, 0x02, 0x77, 0xa9, 0x38, 0xbf,
	0xa0, 0x85, 0x4f, 0x45, 0xef, 0x3e, 0xf5, 0xbf, 0x14, 0x3e, 0xf4, 0x90, 0x4b, 0x81, 0x9e, 0x84,
	0x42, 0xfe, 0x17, 0x39, 0x15, 0xdc, 0xa5, 0x25, 0xb6, 0x90, 0x8b, 0x38, 0x3d, 0xf5, 0xc6, 0x99,
	0x79, 0x9e, 0xd9, 0x9d, 0x67, 0x67, 0x46, 0x82, 0x5b, 0xa7, 0xad, 0x31, 0x99, 0xb7, 0x46, 0xc4,
	0xc6, 0xa3, 0xe6, 0xcc, 0x27, 0x8c, 0xa0, 0xe4, 0x98, 0xcc, 0x2b, 0xfb, 0x63, 0x87, 0x4d, 0x82,
	0x93, 0xe6, 0x88, 0x4c, 0x5b, 0x63, 0x32, 0x26, 0x2d, 0x1e, 0x3b, 0x09, 0x9e, 0x72, 0x8b, 0x1b,
	0xfc, 0x4b, 0x70, 0xea, 0x3f, 0x48, 0x00, 0xaa, 0x8b, 0x47, 0x8c, 0xf8, 0x16, 0xc3, 0xe8, 0x7f,
	0xb0, 0xcd, 0x1c, 0xe6, 0x62, 0x59, 0x52, 0xa4, 0x46, 0x4e, 0x17, 0x06, 0x6a, 0x42, 0x16, 0x0b,
	0x0c, 0x95, 0x13, 0x4a, 0xb2, 0x91, 0x3f, 0x28, 0x34, 0xc7, 0x64, 0xde, 0x8c, 0x88, 0x9d, 0xd4,
	0xc5, 0xa2, 0xb6, 0xa5, 0xaf, 0x30, 0xe8, 0x63, 0xd8, 0x35, 0x08, 0xb3, 0xdc, 0xaf, 0xb1, 0x33,
	0x9e, 0xb0, 0x75, 0x7a, 0x39, 0xa9, 0x48, 0x8d, 0x94, 0xbe, 0x39, 0x58, 0xc7, 0x90, 0x89, 0x2c,
	0xd4, 0x81, 0x1c, 0x75, 0xc6, 0x9e, 0xc5, 0x02, 0x5f, 0x5c, 0xa5, 0xd0, 0xb9, 0xf3, 0x72, 0x51,
	0x53, 0x62, 0xb5, 0x39, 0x64, 0xbe, 0x4f, 0x3c, 0xdc, 0x7a, 0x86, 0xad, 0x39, 0x6e, 0xb6, 0x6d,
	0xdb, 0xc7, 0x94, 0xea, 0x6b, 0x1a, 0xfa, 0x3f, 0xa4, 0x9f, 0xf1, 0x23, 0xe4, 0x84, 0x22, 0x35,
	0x8a, 0x7a, 0x64, 0xd5, 0xbf, 0x97, 0xa0, 0xc0, 0xcf, 0x71, 0x88, 0xa7, 0x07, 0xee, 0xf5, 0x35,
	0xdf, 0x9e, 0x13, 0xe6, 0x78, 0x63, 0x73, 0x86, 0x7d, 0x87, 0xd8, 0xe6, 0x84, 0x04, 0x3e, 0xe5,
	0x15, 0x14, 0xf5, 0x5b, 0x22, 0x34, 0xe0, 0x91, 0x2f, 0xc3, 0x00, 0xba, 0x07, 0x39, 0x36, 0xf1,
	0x31, 0x9d, 0x10, 0xd7, 0x96, 0x53, 0x8a, 0xd4, 0xc8, 0x1f, 0x14, 0xb9, 0x48, 0x0f, 0x7c, 0x8b,
	0x9f, 0x15, 0xa9, 0xb4, 0x46, 0xd5, 0x1f, 0x42, 0xf6, 0x2a, 0x88, 0xf6, 0x20, 0xe7, 0x05, 0x53,
	0xec, 0x5b, 0x8c, 0xf8, 0xfc, 0x22, 0x45, 0x7d, 0xed, 0x40, 0x0a, 0xe4, 0x6d, 0xec, 0x91, 0xa9,
	0xe3, 0xf1, 0xb8, 0x28, 0x28, 0xee, 0xaa, 0xff, 0x92, 0x86, 0x82, 0x81, 0x4f, 0xd9, 0xc0, 0x27,
	0x33, 0x42, 0x2d, 0xf7, 0x9a, 0xaa, 0x78, 0x22, 0x3a, 0xf2, 0x9d, 0x59, 0x78, 0x2a, 0x4f, 0x94,
	0xd3, 0xe3, 0x2e, 0x74, 0x1f, 0xca, 0x38, 0x52, 0xc7, 0xf4, 0x03, 0x17, 0x9b, 0x8e, 0xcd, 0x8b,
	0x2e, 0x74, 0xd0, 0x72, 0x51, 0x2b, 0xc5, 0x95, 0xd3, 0xba, 0x7a, 0x09, 0xc7, 0x6d, 0x1b, 0x7d,
	0x02, 0x45, 0xbc, 0x7a, 0xd1, 0x90, 0x9a, 0xe2, 0xd4, 0xf2, 0x72, 0x51, 0x2b, 0xac, 0x9f, 0x5a,
	0xeb, 0xea, 0x85, 0x35, 0x4c, 0xb3, 0xd1, 0x57, 0x10, 0x29, 0x6a, 0x52, 0x66, 0xf9, 0xcc, 0x64,
	0xce, 0x14, 0xcb, 0xdb, 0x8a, 0xd4, 0x48, 0x76, 0xee, 0xbe, 0x5c, 0xd4, 0xde, 0xb9, 0xf6, 0xdd,
	0x8f, 0x3c, 0xe7, 0xd4, 0x70, 0xa6, 0x58, 0xdf, 0x11, 0xfc, 0x61, 0x48, 0x0f, 0x1d, 0xe8, 0x31,
	0x44, 0x2e, 0x13, 0x7b, 0xb6, 0x48, 0x98, 0xbe, 0x49, 0xc2, 0xa2, 0x60, 0xab, 0x9e, 0xcd, 0xd3,
	0xf5, 0x60, 0x87, 0x06, 0x27, 0x53, 0x87, 0xd2, 0x50, 0x18, 0x9e, 0x2e, 0x73, 0x93, 0x74, 0xa5,
	0x35, 0x9b, 0xe7, 0xbb, 0x0f, 0x69, 0x2b, 0x60, 0x13, 0xe2, 0xcb, 0xd9, 0x1b, 0xb4, 0x77, 0xc4,
	0x41, 0x35, 0xd8, 0x9e, 0x13, 0x86, 0xa9, 0x9c, 0xe3, 0xd3, 0x98, 0xe3, 0x8d, 0x76, 0x4c, 0x18,
	0xd6, 0x85, 0x1f, 0x7d, 0x06, 0xf9, 0xf0, 0xc3, 0xf4, 0x31, 0x0d, 0x5c, 0x26, 0x03, 0xef, 0xc7,
	0x32, 0x87, 0x19, 0x96, 0xeb, 0x3e, 0xd7, 0xb9, 0x3f, 0x6a, 0x49, 0x08, 0xa1, 0xc2, 0x83, 0x3e,
	0x84, 0x34, 0x65, 0x16, 0x0b, 0xa8, 0x9c, 0x57, 0xa4, 0x46, 0xe9, 0x40, 0x16, 0x9c, 0x58, 0x67,
	0x35, 0x87, 0x3c, 0xae, 0x47, 0xb8, 0xfa, 0xaf, 0x12, 0xa4, 0x85, 0x0b, 0xed, 0xc3, 0x9e, 0xa1,
	0x7e, 0x63, 0x98, 0x03, 0xbd, 0x3f, 0xe8, 0x0f, 0xdb, 0x8f, 0xcc, 0xa1, 0xd1, 0x36, 0x8e, 0x86,
	0xa6, 0xd6, 0x3b, 0x6e, 0x3f, 0xd2, 0xba, 0xe5, 0xad, 0x4a, 0xfe, 0xec, 0x5c, 0xc9, 0x68, 0xde,
	0xdc, 0x72, 0x1d, 0x1b, 0xdd, 0x83, 0xea, 0x46, 0xf8, 0x51, 0xaf, 0xab, 0x3e, 0xd0, 0x7a, 0x6a,
	0xb7, 0x2c, 0x55, 0x8a, 0x67, 0xe7, 0x4a, 0xee, 0xc8, 0xb3, 0xf1, 0x53, 0xc7, 0xc3, 0x36, 0x6a,
	0xc1, 0xdb, 0x1b, 0x29, 0xed, 0xc3, 0x43, 0x75, 0x60, 0xa8, 0xdd, 0x72, 0xa2, 0x52, 0x38, 0x3b,
	0x57, 0xb2, 0xed, 0xd1, 0x08, 0xcf, 0xd8, 0x3f, 0x10, 0x74, 0xf5, 0xa1, 0x7a, 0x18, 0x12, 0x92,
	0x82, 0xa0, 0xe3, 0xef, 0xf0, 0x88, 0x61, 0xbb, 0xfe, 0x9b, 0x04, 0xf9, 0x98, 0x44, 0xe8, 0x2d,
	0xc8, 0xb1, 0x70, 0x5d, 0x99, 0xcf, 0x31, 0x8d, 0x06, 0x33, 0xcb, 0x1d, 0x4f, 0x30, 0x45, 0x6f,
	0x82, 0xf8, 0x36, 0x3d, 0x12, 0x0d, 0x65, 0x86, 0xdb, 0x3d, 0x82, 0xde, 0x85, 0xa2, 0x08, 0x59,
	0x27, 0x94, 0x59, 0x8e, 0x17, 0x6d, 0x8e, 0x02, 0x77, 0xb6, 0x85, 0x0f, 0x7d, 0x0a, 0x6f, 0x08,
	0x90, 0xd8, 0x4d, 0xe6, 0x7a, 0x28, 0xf8, 0xe0, 0xa4, 0xf4, 0x5d, 0xb6, 0x69, 0x55, 0xfe, 0x75,
	0xd9, 0x6c, 0xbf, 0xd2, 0xb2, 0xf9, 0x16, 0x52, 0x61, 0x83, 0xa0, 0x0f, 0x20, 0x13, 0x9d, 0xc2,
	0xab, 0xd9, 0xbc, 0xca, 0xaf, 0x20, 0xe8, 0xae, 0x68, 0x34, 0x9b, 0x57, 0x57, 0x3a, 0xd8, 0x59,
	0x35, 0x5a, 0x9f, 0x6f, 0x0b, 0xd1, 0x6e, 0x76, 0xfd, 0x22, 0x01, 0xbb, 0x87, 0x3e, 0xb6, 0x18,
	0x8e, 0x77, 0xca, 0x63, 0x3a, 0xfe, 0x6f, 0xad, 0xa1, 0x2e, 0xc0, 0xeb, 0xee, 0x9f, 0x1c, 0x5d,
	0x6d, 0x9e, 0x7f, 0x35, 0xda, 0xf5, 0x9f, 0x25, 0xc8, 0x84, 0x02, 0x87, 0xe2, 0xb5, 0x20, 0x3f,
	0x8b, 0xb4, 0x0c, 0x8b, 0x10, 0x3f, 0x84, 0xa5, 0xe5, 0xa2, 0x06, 0x57, 0x12, 0x6b, 0x5d, 0x1d,
	0xae, 0x20, 0x9a, 0x8d, 0x3e, 0x17, 0xcf, 0x25, 0x7e, 0x21, 0x5e, 0xf5, 0x64, 0x41, 0x41, 0xef,
	0x43, 0x96, 0x72, 0x35, 0xb0, 0x50, 0x7a, 0xc3, 0x6b, 0xaf, 0x00, 0xf5, 0x2f, 0x20, 0xcb, 0x87,
	0xe4, 0x75, 0x6e, 0xf9, 0xde, 0x4f, 0x12, 0xc0, 0x3a, 0x2b, 0xba, 0x03, 0xb7, 0x8f, 0xfb, 0x86,
	0x6a, 0xf6, 0x07, 0x86, 0xd6, 0xef, 0x5d, 0xb7, 0x2c, 0xf6, 0x60, 0x27, 0x8e, 0x7a, 0xa2, 0x0e,
	0xcb, 0x52, 0x25, 0x73, 0x76, 0xae, 0x24, 0xc3, 0x41, 0xac, 0x40, 0x29, 0x1e, 0xed, 0xf5, 0xcb,
	0x89, 0x4a, 0xfa, 0xec, 0x5c, 0x49, 0xf4, 0xc8, 0xdf, 0xf3, 0xb7, 0x3b, 0x43, 0xa3, 0xad, 0xf5,
	0xca, 0x49, 0x91, 0x3f, 0x1a, 0xc5, 0x8e, 0x7c, 0xb1, 0xac, 0x4a, 0x2f, 0x96, 0x55, 0xe9, 0x8f,
	0x65, 0x55, 0xfa, 0xf1, 0xb2, 0xba, 0xf5, 0xe2, 0xb2, 0xba, 0xf5, 0xfb, 0x65, 0x75, 0xeb, 0x24,
	0xcd, 0xff, 0x29, 0x7d, 0xf4, 0x67, 0x00, 0x00, 0x00, 0xff, 0xff, 0xaf, 0xc4, 0xc3, 0x59, 0x72,
	0x09, 0x00, 0x00,
}

func (m *Electorate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Electorate) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Title) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintCodec(dAtA, i, uint64(len(m.Title)))
		i += copy(dAtA[i:], m.Title)
	}
	if len(m.Electors) > 0 {
		for _, msg := range m.Electors {
			dAtA[i] = 0x12
			i++
			i = encodeVarintCodec(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.TotalWeightElectorate != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintCodec(dAtA, i, uint64(m.TotalWeightElectorate))
	}
	return i, nil
}

func (m *Elector) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Elector) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Signature) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintCodec(dAtA, i, uint64(len(m.Signature)))
		i += copy(dAtA[i:], m.Signature)
	}
	if m.Weight != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintCodec(dAtA, i, uint64(m.Weight))
	}
	return i, nil
}

func (m *ElectionRule) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ElectionRule) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Title) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintCodec(dAtA, i, uint64(len(m.Title)))
		i += copy(dAtA[i:], m.Title)
	}
	if m.VotingPeriodHours != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintCodec(dAtA, i, uint64(m.VotingPeriodHours))
	}
	dAtA[i] = 0x22
	i++
	i = encodeVarintCodec(dAtA, i, uint64(m.Threshold.Size()))
	n1, err := m.Threshold.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n1
	return i, nil
}

func (m *Fraction) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Fraction) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Numerator != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintCodec(dAtA, i, uint64(m.Numerator))
	}
	if m.Denominator != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintCodec(dAtA, i, uint64(m.Denominator))
	}
	return i, nil
}

func (m *TextProposal) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TextProposal) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Title) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintCodec(dAtA, i, uint64(len(m.Title)))
		i += copy(dAtA[i:], m.Title)
	}
	if len(m.Description) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintCodec(dAtA, i, uint64(len(m.Description)))
		i += copy(dAtA[i:], m.Description)
	}
	if len(m.ElectionRuleID) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintCodec(dAtA, i, uint64(len(m.ElectionRuleID)))
		i += copy(dAtA[i:], m.ElectionRuleID)
	}
	if len(m.ElectorateID) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintCodec(dAtA, i, uint64(len(m.ElectorateID)))
		i += copy(dAtA[i:], m.ElectorateID)
	}
	if m.VotingStartTime != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintCodec(dAtA, i, uint64(m.VotingStartTime))
	}
	if m.VotingEndTime != 0 {
		dAtA[i] = 0x30
		i++
		i = encodeVarintCodec(dAtA, i, uint64(m.VotingEndTime))
	}
	if m.SubmissionTime != 0 {
		dAtA[i] = 0x38
		i++
		i = encodeVarintCodec(dAtA, i, uint64(m.SubmissionTime))
	}
	if len(m.Author) > 0 {
		dAtA[i] = 0x42
		i++
		i = encodeVarintCodec(dAtA, i, uint64(len(m.Author)))
		i += copy(dAtA[i:], m.Author)
	}
	if len(m.Votes) > 0 {
		for _, msg := range m.Votes {
			dAtA[i] = 0x4a
			i++
			i = encodeVarintCodec(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	dAtA[i] = 0x52
	i++
	i = encodeVarintCodec(dAtA, i, uint64(m.VoteResult.Size()))
	n2, err := m.VoteResult.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n2
	if m.Status != 0 {
		dAtA[i] = 0x58
		i++
		i = encodeVarintCodec(dAtA, i, uint64(m.Status))
	}
	return i, nil
}

func (m *TallyResult) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TallyResult) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.TotalYes != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintCodec(dAtA, i, uint64(m.TotalYes))
	}
	if m.TotalNo != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintCodec(dAtA, i, uint64(m.TotalNo))
	}
	if m.TotalAbstain != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintCodec(dAtA, i, uint64(m.TotalAbstain))
	}
	if m.TotalWeightElectorate != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintCodec(dAtA, i, uint64(m.TotalWeightElectorate))
	}
	dAtA[i] = 0x2a
	i++
	i = encodeVarintCodec(dAtA, i, uint64(m.Threshold.Size()))
	n3, err := m.Threshold.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n3
	return i, nil
}

func (m *Vote) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Vote) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0xa
	i++
	i = encodeVarintCodec(dAtA, i, uint64(m.Elector.Size()))
	n4, err := m.Elector.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n4
	if m.Voted != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintCodec(dAtA, i, uint64(m.Voted))
	}
	return i, nil
}

func (m *CreateTextProposalMsg) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CreateTextProposalMsg) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Title) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintCodec(dAtA, i, uint64(len(m.Title)))
		i += copy(dAtA[i:], m.Title)
	}
	if len(m.Description) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintCodec(dAtA, i, uint64(len(m.Description)))
		i += copy(dAtA[i:], m.Description)
	}
	if len(m.ElectionRuleID) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintCodec(dAtA, i, uint64(len(m.ElectionRuleID)))
		i += copy(dAtA[i:], m.ElectionRuleID)
	}
	if len(m.ElectorateID) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintCodec(dAtA, i, uint64(len(m.ElectorateID)))
		i += copy(dAtA[i:], m.ElectorateID)
	}
	if m.StartTime != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintCodec(dAtA, i, uint64(m.StartTime))
	}
	if len(m.Author) > 0 {
		dAtA[i] = 0x42
		i++
		i = encodeVarintCodec(dAtA, i, uint64(len(m.Author)))
		i += copy(dAtA[i:], m.Author)
	}
	return i, nil
}

func (m *VoteMsg) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *VoteMsg) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.ProposalID) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintCodec(dAtA, i, uint64(len(m.ProposalID)))
		i += copy(dAtA[i:], m.ProposalID)
	}
	if len(m.Voter) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintCodec(dAtA, i, uint64(len(m.Voter)))
		i += copy(dAtA[i:], m.Voter)
	}
	if m.Selected != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintCodec(dAtA, i, uint64(m.Selected))
	}
	return i, nil
}

func (m *TallyMsg) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TallyMsg) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.ProposalID) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintCodec(dAtA, i, uint64(len(m.ProposalID)))
		i += copy(dAtA[i:], m.ProposalID)
	}
	return i, nil
}

func encodeVarintCodec(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
func (m *Electorate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Title)
	if l > 0 {
		n += 1 + l + sovCodec(uint64(l))
	}
	if len(m.Electors) > 0 {
		for _, e := range m.Electors {
			l = e.Size()
			n += 1 + l + sovCodec(uint64(l))
		}
	}
	if m.TotalWeightElectorate != 0 {
		n += 1 + sovCodec(uint64(m.TotalWeightElectorate))
	}
	return n
}

func (m *Elector) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Signature)
	if l > 0 {
		n += 1 + l + sovCodec(uint64(l))
	}
	if m.Weight != 0 {
		n += 1 + sovCodec(uint64(m.Weight))
	}
	return n
}

func (m *ElectionRule) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Title)
	if l > 0 {
		n += 1 + l + sovCodec(uint64(l))
	}
	if m.VotingPeriodHours != 0 {
		n += 1 + sovCodec(uint64(m.VotingPeriodHours))
	}
	l = m.Threshold.Size()
	n += 1 + l + sovCodec(uint64(l))
	return n
}

func (m *Fraction) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Numerator != 0 {
		n += 1 + sovCodec(uint64(m.Numerator))
	}
	if m.Denominator != 0 {
		n += 1 + sovCodec(uint64(m.Denominator))
	}
	return n
}

func (m *TextProposal) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Title)
	if l > 0 {
		n += 1 + l + sovCodec(uint64(l))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCodec(uint64(l))
	}
	l = len(m.ElectionRuleID)
	if l > 0 {
		n += 1 + l + sovCodec(uint64(l))
	}
	l = len(m.ElectorateID)
	if l > 0 {
		n += 1 + l + sovCodec(uint64(l))
	}
	if m.VotingStartTime != 0 {
		n += 1 + sovCodec(uint64(m.VotingStartTime))
	}
	if m.VotingEndTime != 0 {
		n += 1 + sovCodec(uint64(m.VotingEndTime))
	}
	if m.SubmissionTime != 0 {
		n += 1 + sovCodec(uint64(m.SubmissionTime))
	}
	l = len(m.Author)
	if l > 0 {
		n += 1 + l + sovCodec(uint64(l))
	}
	if len(m.Votes) > 0 {
		for _, e := range m.Votes {
			l = e.Size()
			n += 1 + l + sovCodec(uint64(l))
		}
	}
	l = m.VoteResult.Size()
	n += 1 + l + sovCodec(uint64(l))
	if m.Status != 0 {
		n += 1 + sovCodec(uint64(m.Status))
	}
	return n
}

func (m *TallyResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TotalYes != 0 {
		n += 1 + sovCodec(uint64(m.TotalYes))
	}
	if m.TotalNo != 0 {
		n += 1 + sovCodec(uint64(m.TotalNo))
	}
	if m.TotalAbstain != 0 {
		n += 1 + sovCodec(uint64(m.TotalAbstain))
	}
	if m.TotalWeightElectorate != 0 {
		n += 1 + sovCodec(uint64(m.TotalWeightElectorate))
	}
	l = m.Threshold.Size()
	n += 1 + l + sovCodec(uint64(l))
	return n
}

func (m *Vote) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Elector.Size()
	n += 1 + l + sovCodec(uint64(l))
	if m.Voted != 0 {
		n += 1 + sovCodec(uint64(m.Voted))
	}
	return n
}

func (m *CreateTextProposalMsg) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Title)
	if l > 0 {
		n += 1 + l + sovCodec(uint64(l))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovCodec(uint64(l))
	}
	l = len(m.ElectionRuleID)
	if l > 0 {
		n += 1 + l + sovCodec(uint64(l))
	}
	l = len(m.ElectorateID)
	if l > 0 {
		n += 1 + l + sovCodec(uint64(l))
	}
	if m.StartTime != 0 {
		n += 1 + sovCodec(uint64(m.StartTime))
	}
	l = len(m.Author)
	if l > 0 {
		n += 1 + l + sovCodec(uint64(l))
	}
	return n
}

func (m *VoteMsg) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ProposalID)
	if l > 0 {
		n += 1 + l + sovCodec(uint64(l))
	}
	l = len(m.Voter)
	if l > 0 {
		n += 1 + l + sovCodec(uint64(l))
	}
	if m.Selected != 0 {
		n += 1 + sovCodec(uint64(m.Selected))
	}
	return n
}

func (m *TallyMsg) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ProposalID)
	if l > 0 {
		n += 1 + l + sovCodec(uint64(l))
	}
	return n
}

func sovCodec(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozCodec(x uint64) (n int) {
	return sovCodec(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Electorate) 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 ErrIntOverflowCodec
			}
			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: Electorate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Electorate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCodec
				}
				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 ErrInvalidLengthCodec
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCodec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Title = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Electors", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCodec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCodec
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCodec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Electors = append(m.Electors, Elector{})
			if err := m.Electors[len(m.Electors)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalWeightElectorate", wireType)
			}
			m.TotalWeightElectorate = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCodec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TotalWeightElectorate |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCodec(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCodec
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCodec
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Elector) 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 ErrIntOverflowCodec
			}
			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: Elector: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Elector: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCodec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthCodec
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthCodec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...)
			if m.Signature == nil {
				m.Signature = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Weight", wireType)
			}
			m.Weight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCodec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Weight |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCodec(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCodec
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCodec
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ElectionRule) 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 ErrIntOverflowCodec
			}
			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: ElectionRule: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ElectionRule: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCodec
				}
				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 ErrInvalidLengthCodec
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCodec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Title = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field VotingPeriodHours", wireType)
			}
			m.VotingPeriodHours = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCodec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.VotingPeriodHours |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Threshold", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCodec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCodec
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCodec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Threshold.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCodec(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCodec
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCodec
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Fraction) 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 ErrIntOverflowCodec
			}
			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: Fraction: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Fraction: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Numerator", wireType)
			}
			m.Numerator = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCodec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Numerator |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Denominator", wireType)
			}
			m.Denominator = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCodec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Denominator |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCodec(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCodec
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCodec
			}
			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
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowCodec
			}
			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: TextProposal: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TextProposal: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCodec
				}
				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 ErrInvalidLengthCodec
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCodec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Title = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCodec
				}
				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 ErrInvalidLengthCodec
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCodec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ElectionRuleID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCodec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthCodec
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthCodec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ElectionRuleID = append(m.ElectionRuleID[:0], dAtA[iNdEx:postIndex]...)
			if m.ElectionRuleID == nil {
				m.ElectionRuleID = []byte{}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ElectorateID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCodec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthCodec
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthCodec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ElectorateID = append(m.ElectorateID[:0], dAtA[iNdEx:postIndex]...)
			if m.ElectorateID == nil {
				m.ElectorateID = []byte{}
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field VotingStartTime", wireType)
			}
			m.VotingStartTime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCodec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.VotingStartTime |= github_com_iov_one_weave.UnixTime(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field VotingEndTime", wireType)
			}
			m.VotingEndTime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCodec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.VotingEndTime |= github_com_iov_one_weave.UnixTime(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubmissionTime", wireType)
			}
			m.SubmissionTime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCodec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SubmissionTime |= github_com_iov_one_weave.UnixTime(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Author", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCodec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthCodec
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthCodec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Author = append(m.Author[:0], dAtA[iNdEx:postIndex]...)
			if m.Author == nil {
				m.Author = []byte{}
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Votes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCodec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCodec
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCodec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Votes = append(m.Votes, &Vote{})
			if err := m.Votes[len(m.Votes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VoteResult", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCodec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCodec
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCodec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.VoteResult.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCodec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= TextProposal_Status(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCodec(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCodec
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCodec
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TallyResult) 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 ErrIntOverflowCodec
			}
			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: TallyResult: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TallyResult: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalYes", wireType)
			}
			m.TotalYes = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCodec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TotalYes |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalNo", wireType)
			}
			m.TotalNo = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCodec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TotalNo |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalAbstain", wireType)
			}
			m.TotalAbstain = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCodec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TotalAbstain |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalWeightElectorate", wireType)
			}
			m.TotalWeightElectorate = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCodec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TotalWeightElectorate |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Threshold", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCodec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCodec
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCodec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Threshold.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCodec(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCodec
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCodec
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Vote) 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 ErrIntOverflowCodec
			}
			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: Vote: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Vote: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Elector", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCodec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCodec
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCodec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Elector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Voted", wireType)
			}
			m.Voted = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCodec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Voted |= VoteOption(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCodec(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCodec
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCodec
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CreateTextProposalMsg) 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 ErrIntOverflowCodec
			}
			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: CreateTextProposalMsg: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreateTextProposalMsg: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCodec
				}
				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 ErrInvalidLengthCodec
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCodec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Title = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCodec
				}
				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 ErrInvalidLengthCodec
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCodec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ElectionRuleID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCodec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthCodec
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthCodec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ElectionRuleID = append(m.ElectionRuleID[:0], dAtA[iNdEx:postIndex]...)
			if m.ElectionRuleID == nil {
				m.ElectionRuleID = []byte{}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ElectorateID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCodec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthCodec
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthCodec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ElectorateID = append(m.ElectorateID[:0], dAtA[iNdEx:postIndex]...)
			if m.ElectorateID == nil {
				m.ElectorateID = []byte{}
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartTime", wireType)
			}
			m.StartTime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCodec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StartTime |= github_com_iov_one_weave.UnixTime(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Author", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCodec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthCodec
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthCodec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Author = append(m.Author[:0], dAtA[iNdEx:postIndex]...)
			if m.Author == nil {
				m.Author = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCodec(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCodec
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCodec
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *VoteMsg) 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 ErrIntOverflowCodec
			}
			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: VoteMsg: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: VoteMsg: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProposalID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCodec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthCodec
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthCodec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ProposalID = append(m.ProposalID[:0], dAtA[iNdEx:postIndex]...)
			if m.ProposalID == nil {
				m.ProposalID = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Voter", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCodec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthCodec
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthCodec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Voter = append(m.Voter[:0], dAtA[iNdEx:postIndex]...)
			if m.Voter == nil {
				m.Voter = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Selected", wireType)
			}
			m.Selected = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCodec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Selected |= VoteOption(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCodec(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCodec
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCodec
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TallyMsg) 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 ErrIntOverflowCodec
			}
			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: TallyMsg: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TallyMsg: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProposalID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCodec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthCodec
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthCodec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ProposalID = append(m.ProposalID[:0], dAtA[iNdEx:postIndex]...)
			if m.ProposalID == nil {
				m.ProposalID = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCodec(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCodec
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCodec
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipCodec(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowCodec
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowCodec
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
			return iNdEx, nil
		case 1:
			iNdEx += 8
			return iNdEx, nil
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowCodec
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthCodec
			}
			iNdEx += length
			if iNdEx < 0 {
				return 0, ErrInvalidLengthCodec
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowCodec
					}
					if iNdEx >= l {
						return 0, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					innerWire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				innerWireType := int(innerWire & 0x7)
				if innerWireType == 4 {
					break
				}
				next, err := skipCodec(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
				if iNdEx < 0 {
					return 0, ErrInvalidLengthCodec
				}
			}
			return iNdEx, nil
		case 4:
			return iNdEx, nil
		case 5:
			iNdEx += 4
			return iNdEx, nil
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
	}
	panic("unreachable")
}

var (
	ErrInvalidLengthCodec = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowCodec   = fmt.Errorf("proto: integer overflow")
)