tx.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: osmosis/valsetpref/v1beta1/tx.proto

package types

import (
	context "context"
	fmt "fmt"
	types "github.com/cosmos/cosmos-sdk/types"
	_ "github.com/cosmos/cosmos-sdk/types/tx/amino"
	_ "github.com/cosmos/gogoproto/gogoproto"
	grpc1 "github.com/cosmos/gogoproto/grpc"
	proto "github.com/cosmos/gogoproto/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	_ "google.golang.org/protobuf/types/known/timestamppb"
	io "io"
	math "math"
	math_bits "math/bits"
)

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

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

// MsgCreateValidatorSetPreference is a list that holds validator-set.
type MsgSetValidatorSetPreference struct {
	// delegator is the user who is trying to create a validator-set.
	Delegator string `protobuf:"bytes,1,opt,name=delegator,proto3" json:"delegator,omitempty" yaml:"delegator"`
	// list of {valAddr, weight} to delegate to
	Preferences []ValidatorPreference `protobuf:"bytes,2,rep,name=preferences,proto3" json:"preferences" yaml:"preferences"`
}

func (m *MsgSetValidatorSetPreference) Reset()         { *m = MsgSetValidatorSetPreference{} }
func (m *MsgSetValidatorSetPreference) String() string { return proto.CompactTextString(m) }
func (*MsgSetValidatorSetPreference) ProtoMessage()    {}
func (*MsgSetValidatorSetPreference) Descriptor() ([]byte, []int) {
	return fileDescriptor_3fff1326c2fd6b4c, []int{0}
}
func (m *MsgSetValidatorSetPreference) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgSetValidatorSetPreference) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgSetValidatorSetPreference.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 *MsgSetValidatorSetPreference) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgSetValidatorSetPreference.Merge(m, src)
}
func (m *MsgSetValidatorSetPreference) XXX_Size() int {
	return m.Size()
}
func (m *MsgSetValidatorSetPreference) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgSetValidatorSetPreference.DiscardUnknown(m)
}

var xxx_messageInfo_MsgSetValidatorSetPreference proto.InternalMessageInfo

func (m *MsgSetValidatorSetPreference) GetDelegator() string {
	if m != nil {
		return m.Delegator
	}
	return ""
}

func (m *MsgSetValidatorSetPreference) GetPreferences() []ValidatorPreference {
	if m != nil {
		return m.Preferences
	}
	return nil
}

type MsgSetValidatorSetPreferenceResponse struct {
}

func (m *MsgSetValidatorSetPreferenceResponse) Reset()         { *m = MsgSetValidatorSetPreferenceResponse{} }
func (m *MsgSetValidatorSetPreferenceResponse) String() string { return proto.CompactTextString(m) }
func (*MsgSetValidatorSetPreferenceResponse) ProtoMessage()    {}
func (*MsgSetValidatorSetPreferenceResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_3fff1326c2fd6b4c, []int{1}
}
func (m *MsgSetValidatorSetPreferenceResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgSetValidatorSetPreferenceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgSetValidatorSetPreferenceResponse.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 *MsgSetValidatorSetPreferenceResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgSetValidatorSetPreferenceResponse.Merge(m, src)
}
func (m *MsgSetValidatorSetPreferenceResponse) XXX_Size() int {
	return m.Size()
}
func (m *MsgSetValidatorSetPreferenceResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgSetValidatorSetPreferenceResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MsgSetValidatorSetPreferenceResponse proto.InternalMessageInfo

// MsgDelegateToValidatorSet allows users to delegate to an existing
// validator-set
type MsgDelegateToValidatorSet struct {
	// delegator is the user who is trying to delegate.
	Delegator string `protobuf:"bytes,1,opt,name=delegator,proto3" json:"delegator,omitempty" yaml:"delegator"`
	// the amount of tokens the user is trying to delegate.
	// For ex: delegate 10osmo with validator-set {ValA -> 0.5, ValB -> 0.3, ValC
	// -> 0.2} our staking logic would attempt to delegate 5osmo to A , 3osmo to
	// B, 2osmo to C.
	Coin types.Coin `protobuf:"bytes,2,opt,name=coin,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coin" json:"coin"`
}

func (m *MsgDelegateToValidatorSet) Reset()         { *m = MsgDelegateToValidatorSet{} }
func (m *MsgDelegateToValidatorSet) String() string { return proto.CompactTextString(m) }
func (*MsgDelegateToValidatorSet) ProtoMessage()    {}
func (*MsgDelegateToValidatorSet) Descriptor() ([]byte, []int) {
	return fileDescriptor_3fff1326c2fd6b4c, []int{2}
}
func (m *MsgDelegateToValidatorSet) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgDelegateToValidatorSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgDelegateToValidatorSet.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 *MsgDelegateToValidatorSet) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgDelegateToValidatorSet.Merge(m, src)
}
func (m *MsgDelegateToValidatorSet) XXX_Size() int {
	return m.Size()
}
func (m *MsgDelegateToValidatorSet) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgDelegateToValidatorSet.DiscardUnknown(m)
}

var xxx_messageInfo_MsgDelegateToValidatorSet proto.InternalMessageInfo

func (m *MsgDelegateToValidatorSet) GetDelegator() string {
	if m != nil {
		return m.Delegator
	}
	return ""
}

func (m *MsgDelegateToValidatorSet) GetCoin() types.Coin {
	if m != nil {
		return m.Coin
	}
	return types.Coin{}
}

type MsgDelegateToValidatorSetResponse struct {
}

func (m *MsgDelegateToValidatorSetResponse) Reset()         { *m = MsgDelegateToValidatorSetResponse{} }
func (m *MsgDelegateToValidatorSetResponse) String() string { return proto.CompactTextString(m) }
func (*MsgDelegateToValidatorSetResponse) ProtoMessage()    {}
func (*MsgDelegateToValidatorSetResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_3fff1326c2fd6b4c, []int{3}
}
func (m *MsgDelegateToValidatorSetResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgDelegateToValidatorSetResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgDelegateToValidatorSetResponse.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 *MsgDelegateToValidatorSetResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgDelegateToValidatorSetResponse.Merge(m, src)
}
func (m *MsgDelegateToValidatorSetResponse) XXX_Size() int {
	return m.Size()
}
func (m *MsgDelegateToValidatorSetResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgDelegateToValidatorSetResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MsgDelegateToValidatorSetResponse proto.InternalMessageInfo

type MsgUndelegateFromValidatorSet struct {
	// delegator is the user who is trying to undelegate.
	Delegator string `protobuf:"bytes,1,opt,name=delegator,proto3" json:"delegator,omitempty" yaml:"delegator"`
	// the amount the user wants to undelegate
	// For ex: Undelegate 10osmo with validator-set {ValA -> 0.5, ValB -> 0.3,
	// ValC
	// -> 0.2} our undelegate logic would attempt to undelegate 5osmo from A ,
	// 3osmo from B, 2osmo from C
	Coin types.Coin `protobuf:"bytes,3,opt,name=coin,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coin" json:"coin"`
}

func (m *MsgUndelegateFromValidatorSet) Reset()         { *m = MsgUndelegateFromValidatorSet{} }
func (m *MsgUndelegateFromValidatorSet) String() string { return proto.CompactTextString(m) }
func (*MsgUndelegateFromValidatorSet) ProtoMessage()    {}
func (*MsgUndelegateFromValidatorSet) Descriptor() ([]byte, []int) {
	return fileDescriptor_3fff1326c2fd6b4c, []int{4}
}
func (m *MsgUndelegateFromValidatorSet) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgUndelegateFromValidatorSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgUndelegateFromValidatorSet.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 *MsgUndelegateFromValidatorSet) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgUndelegateFromValidatorSet.Merge(m, src)
}
func (m *MsgUndelegateFromValidatorSet) XXX_Size() int {
	return m.Size()
}
func (m *MsgUndelegateFromValidatorSet) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgUndelegateFromValidatorSet.DiscardUnknown(m)
}

var xxx_messageInfo_MsgUndelegateFromValidatorSet proto.InternalMessageInfo

func (m *MsgUndelegateFromValidatorSet) GetDelegator() string {
	if m != nil {
		return m.Delegator
	}
	return ""
}

func (m *MsgUndelegateFromValidatorSet) GetCoin() types.Coin {
	if m != nil {
		return m.Coin
	}
	return types.Coin{}
}

type MsgUndelegateFromValidatorSetResponse struct {
}

func (m *MsgUndelegateFromValidatorSetResponse) Reset()         { *m = MsgUndelegateFromValidatorSetResponse{} }
func (m *MsgUndelegateFromValidatorSetResponse) String() string { return proto.CompactTextString(m) }
func (*MsgUndelegateFromValidatorSetResponse) ProtoMessage()    {}
func (*MsgUndelegateFromValidatorSetResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_3fff1326c2fd6b4c, []int{5}
}
func (m *MsgUndelegateFromValidatorSetResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgUndelegateFromValidatorSetResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgUndelegateFromValidatorSetResponse.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 *MsgUndelegateFromValidatorSetResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgUndelegateFromValidatorSetResponse.Merge(m, src)
}
func (m *MsgUndelegateFromValidatorSetResponse) XXX_Size() int {
	return m.Size()
}
func (m *MsgUndelegateFromValidatorSetResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgUndelegateFromValidatorSetResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MsgUndelegateFromValidatorSetResponse proto.InternalMessageInfo

type MsgUndelegateFromRebalancedValidatorSet struct {
	// delegator is the user who is trying to undelegate.
	Delegator string `protobuf:"bytes,1,opt,name=delegator,proto3" json:"delegator,omitempty" yaml:"delegator"`
	// the amount the user wants to undelegate
	// For ex: Undelegate 50 osmo with validator-set {ValA -> 0.5, ValB -> 0.5}
	// Our undelegate logic would first check the current delegation balance.
	// If the user has 90 osmo delegated to ValA and 10 osmo delegated to ValB,
	// the rebalanced validator set would be {ValA -> 0.9, ValB -> 0.1}
	// So now the 45 osmo would be undelegated from ValA and 5 osmo would be
	// undelegated from ValB.
	Coin types.Coin `protobuf:"bytes,2,opt,name=coin,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coin" json:"coin"`
}

func (m *MsgUndelegateFromRebalancedValidatorSet) Reset() {
	*m = MsgUndelegateFromRebalancedValidatorSet{}
}
func (m *MsgUndelegateFromRebalancedValidatorSet) String() string { return proto.CompactTextString(m) }
func (*MsgUndelegateFromRebalancedValidatorSet) ProtoMessage()    {}
func (*MsgUndelegateFromRebalancedValidatorSet) Descriptor() ([]byte, []int) {
	return fileDescriptor_3fff1326c2fd6b4c, []int{6}
}
func (m *MsgUndelegateFromRebalancedValidatorSet) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgUndelegateFromRebalancedValidatorSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgUndelegateFromRebalancedValidatorSet.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 *MsgUndelegateFromRebalancedValidatorSet) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgUndelegateFromRebalancedValidatorSet.Merge(m, src)
}
func (m *MsgUndelegateFromRebalancedValidatorSet) XXX_Size() int {
	return m.Size()
}
func (m *MsgUndelegateFromRebalancedValidatorSet) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgUndelegateFromRebalancedValidatorSet.DiscardUnknown(m)
}

var xxx_messageInfo_MsgUndelegateFromRebalancedValidatorSet proto.InternalMessageInfo

func (m *MsgUndelegateFromRebalancedValidatorSet) GetDelegator() string {
	if m != nil {
		return m.Delegator
	}
	return ""
}

func (m *MsgUndelegateFromRebalancedValidatorSet) GetCoin() types.Coin {
	if m != nil {
		return m.Coin
	}
	return types.Coin{}
}

type MsgUndelegateFromRebalancedValidatorSetResponse struct {
}

func (m *MsgUndelegateFromRebalancedValidatorSetResponse) Reset() {
	*m = MsgUndelegateFromRebalancedValidatorSetResponse{}
}
func (m *MsgUndelegateFromRebalancedValidatorSetResponse) String() string {
	return proto.CompactTextString(m)
}
func (*MsgUndelegateFromRebalancedValidatorSetResponse) ProtoMessage() {}
func (*MsgUndelegateFromRebalancedValidatorSetResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_3fff1326c2fd6b4c, []int{7}
}
func (m *MsgUndelegateFromRebalancedValidatorSetResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgUndelegateFromRebalancedValidatorSetResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgUndelegateFromRebalancedValidatorSetResponse.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 *MsgUndelegateFromRebalancedValidatorSetResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgUndelegateFromRebalancedValidatorSetResponse.Merge(m, src)
}
func (m *MsgUndelegateFromRebalancedValidatorSetResponse) XXX_Size() int {
	return m.Size()
}
func (m *MsgUndelegateFromRebalancedValidatorSetResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgUndelegateFromRebalancedValidatorSetResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MsgUndelegateFromRebalancedValidatorSetResponse proto.InternalMessageInfo

type MsgRedelegateValidatorSet struct {
	// delegator is the user who is trying to create a validator-set.
	Delegator string `protobuf:"bytes,1,opt,name=delegator,proto3" json:"delegator,omitempty" yaml:"delegator"`
	// list of {valAddr, weight} to delegate to
	Preferences []ValidatorPreference `protobuf:"bytes,2,rep,name=preferences,proto3" json:"preferences" yaml:"preferences"`
}

func (m *MsgRedelegateValidatorSet) Reset()         { *m = MsgRedelegateValidatorSet{} }
func (m *MsgRedelegateValidatorSet) String() string { return proto.CompactTextString(m) }
func (*MsgRedelegateValidatorSet) ProtoMessage()    {}
func (*MsgRedelegateValidatorSet) Descriptor() ([]byte, []int) {
	return fileDescriptor_3fff1326c2fd6b4c, []int{8}
}
func (m *MsgRedelegateValidatorSet) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgRedelegateValidatorSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgRedelegateValidatorSet.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 *MsgRedelegateValidatorSet) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgRedelegateValidatorSet.Merge(m, src)
}
func (m *MsgRedelegateValidatorSet) XXX_Size() int {
	return m.Size()
}
func (m *MsgRedelegateValidatorSet) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgRedelegateValidatorSet.DiscardUnknown(m)
}

var xxx_messageInfo_MsgRedelegateValidatorSet proto.InternalMessageInfo

func (m *MsgRedelegateValidatorSet) GetDelegator() string {
	if m != nil {
		return m.Delegator
	}
	return ""
}

func (m *MsgRedelegateValidatorSet) GetPreferences() []ValidatorPreference {
	if m != nil {
		return m.Preferences
	}
	return nil
}

type MsgRedelegateValidatorSetResponse struct {
}

func (m *MsgRedelegateValidatorSetResponse) Reset()         { *m = MsgRedelegateValidatorSetResponse{} }
func (m *MsgRedelegateValidatorSetResponse) String() string { return proto.CompactTextString(m) }
func (*MsgRedelegateValidatorSetResponse) ProtoMessage()    {}
func (*MsgRedelegateValidatorSetResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_3fff1326c2fd6b4c, []int{9}
}
func (m *MsgRedelegateValidatorSetResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgRedelegateValidatorSetResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgRedelegateValidatorSetResponse.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 *MsgRedelegateValidatorSetResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgRedelegateValidatorSetResponse.Merge(m, src)
}
func (m *MsgRedelegateValidatorSetResponse) XXX_Size() int {
	return m.Size()
}
func (m *MsgRedelegateValidatorSetResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgRedelegateValidatorSetResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MsgRedelegateValidatorSetResponse proto.InternalMessageInfo

// MsgWithdrawDelegationRewards allows user to claim staking rewards from the
// validator set.
type MsgWithdrawDelegationRewards struct {
	// delegator is the user who is trying to claim staking rewards.
	Delegator string `protobuf:"bytes,1,opt,name=delegator,proto3" json:"delegator,omitempty" yaml:"delegator"`
}

func (m *MsgWithdrawDelegationRewards) Reset()         { *m = MsgWithdrawDelegationRewards{} }
func (m *MsgWithdrawDelegationRewards) String() string { return proto.CompactTextString(m) }
func (*MsgWithdrawDelegationRewards) ProtoMessage()    {}
func (*MsgWithdrawDelegationRewards) Descriptor() ([]byte, []int) {
	return fileDescriptor_3fff1326c2fd6b4c, []int{10}
}
func (m *MsgWithdrawDelegationRewards) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgWithdrawDelegationRewards) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgWithdrawDelegationRewards.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 *MsgWithdrawDelegationRewards) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgWithdrawDelegationRewards.Merge(m, src)
}
func (m *MsgWithdrawDelegationRewards) XXX_Size() int {
	return m.Size()
}
func (m *MsgWithdrawDelegationRewards) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgWithdrawDelegationRewards.DiscardUnknown(m)
}

var xxx_messageInfo_MsgWithdrawDelegationRewards proto.InternalMessageInfo

func (m *MsgWithdrawDelegationRewards) GetDelegator() string {
	if m != nil {
		return m.Delegator
	}
	return ""
}

type MsgWithdrawDelegationRewardsResponse struct {
}

func (m *MsgWithdrawDelegationRewardsResponse) Reset()         { *m = MsgWithdrawDelegationRewardsResponse{} }
func (m *MsgWithdrawDelegationRewardsResponse) String() string { return proto.CompactTextString(m) }
func (*MsgWithdrawDelegationRewardsResponse) ProtoMessage()    {}
func (*MsgWithdrawDelegationRewardsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_3fff1326c2fd6b4c, []int{11}
}
func (m *MsgWithdrawDelegationRewardsResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgWithdrawDelegationRewardsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgWithdrawDelegationRewardsResponse.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 *MsgWithdrawDelegationRewardsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgWithdrawDelegationRewardsResponse.Merge(m, src)
}
func (m *MsgWithdrawDelegationRewardsResponse) XXX_Size() int {
	return m.Size()
}
func (m *MsgWithdrawDelegationRewardsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgWithdrawDelegationRewardsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MsgWithdrawDelegationRewardsResponse proto.InternalMessageInfo

// MsgDelegateBondedTokens breaks bonded lockup (by ID) of osmo, of
// length <= 2 weeks and takes all that osmo and delegates according to
// delegator's current validator set preference.
type MsgDelegateBondedTokens struct {
	// delegator is the user who is trying to force unbond osmo and delegate.
	Delegator string `protobuf:"bytes,1,opt,name=delegator,proto3" json:"delegator,omitempty" yaml:"delegator"`
	// lockup id of osmo in the pool
	LockID uint64 `protobuf:"varint,2,opt,name=lockID,proto3" json:"lockID,omitempty"`
}

func (m *MsgDelegateBondedTokens) Reset()         { *m = MsgDelegateBondedTokens{} }
func (m *MsgDelegateBondedTokens) String() string { return proto.CompactTextString(m) }
func (*MsgDelegateBondedTokens) ProtoMessage()    {}
func (*MsgDelegateBondedTokens) Descriptor() ([]byte, []int) {
	return fileDescriptor_3fff1326c2fd6b4c, []int{12}
}
func (m *MsgDelegateBondedTokens) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgDelegateBondedTokens) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgDelegateBondedTokens.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 *MsgDelegateBondedTokens) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgDelegateBondedTokens.Merge(m, src)
}
func (m *MsgDelegateBondedTokens) XXX_Size() int {
	return m.Size()
}
func (m *MsgDelegateBondedTokens) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgDelegateBondedTokens.DiscardUnknown(m)
}

var xxx_messageInfo_MsgDelegateBondedTokens proto.InternalMessageInfo

func (m *MsgDelegateBondedTokens) GetDelegator() string {
	if m != nil {
		return m.Delegator
	}
	return ""
}

func (m *MsgDelegateBondedTokens) GetLockID() uint64 {
	if m != nil {
		return m.LockID
	}
	return 0
}

type MsgDelegateBondedTokensResponse struct {
}

func (m *MsgDelegateBondedTokensResponse) Reset()         { *m = MsgDelegateBondedTokensResponse{} }
func (m *MsgDelegateBondedTokensResponse) String() string { return proto.CompactTextString(m) }
func (*MsgDelegateBondedTokensResponse) ProtoMessage()    {}
func (*MsgDelegateBondedTokensResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_3fff1326c2fd6b4c, []int{13}
}
func (m *MsgDelegateBondedTokensResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MsgDelegateBondedTokensResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MsgDelegateBondedTokensResponse.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 *MsgDelegateBondedTokensResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MsgDelegateBondedTokensResponse.Merge(m, src)
}
func (m *MsgDelegateBondedTokensResponse) XXX_Size() int {
	return m.Size()
}
func (m *MsgDelegateBondedTokensResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_MsgDelegateBondedTokensResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MsgDelegateBondedTokensResponse proto.InternalMessageInfo

func init() {
	proto.RegisterType((*MsgSetValidatorSetPreference)(nil), "osmosis.valsetpref.v1beta1.MsgSetValidatorSetPreference")
	proto.RegisterType((*MsgSetValidatorSetPreferenceResponse)(nil), "osmosis.valsetpref.v1beta1.MsgSetValidatorSetPreferenceResponse")
	proto.RegisterType((*MsgDelegateToValidatorSet)(nil), "osmosis.valsetpref.v1beta1.MsgDelegateToValidatorSet")
	proto.RegisterType((*MsgDelegateToValidatorSetResponse)(nil), "osmosis.valsetpref.v1beta1.MsgDelegateToValidatorSetResponse")
	proto.RegisterType((*MsgUndelegateFromValidatorSet)(nil), "osmosis.valsetpref.v1beta1.MsgUndelegateFromValidatorSet")
	proto.RegisterType((*MsgUndelegateFromValidatorSetResponse)(nil), "osmosis.valsetpref.v1beta1.MsgUndelegateFromValidatorSetResponse")
	proto.RegisterType((*MsgUndelegateFromRebalancedValidatorSet)(nil), "osmosis.valsetpref.v1beta1.MsgUndelegateFromRebalancedValidatorSet")
	proto.RegisterType((*MsgUndelegateFromRebalancedValidatorSetResponse)(nil), "osmosis.valsetpref.v1beta1.MsgUndelegateFromRebalancedValidatorSetResponse")
	proto.RegisterType((*MsgRedelegateValidatorSet)(nil), "osmosis.valsetpref.v1beta1.MsgRedelegateValidatorSet")
	proto.RegisterType((*MsgRedelegateValidatorSetResponse)(nil), "osmosis.valsetpref.v1beta1.MsgRedelegateValidatorSetResponse")
	proto.RegisterType((*MsgWithdrawDelegationRewards)(nil), "osmosis.valsetpref.v1beta1.MsgWithdrawDelegationRewards")
	proto.RegisterType((*MsgWithdrawDelegationRewardsResponse)(nil), "osmosis.valsetpref.v1beta1.MsgWithdrawDelegationRewardsResponse")
	proto.RegisterType((*MsgDelegateBondedTokens)(nil), "osmosis.valsetpref.v1beta1.MsgDelegateBondedTokens")
	proto.RegisterType((*MsgDelegateBondedTokensResponse)(nil), "osmosis.valsetpref.v1beta1.MsgDelegateBondedTokensResponse")
}

func init() {
	proto.RegisterFile("osmosis/valsetpref/v1beta1/tx.proto", fileDescriptor_3fff1326c2fd6b4c)
}

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

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// MsgClient is the client API for Msg service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type MsgClient interface {
	// SetValidatorSetPreference creates a set of validator preference.
	// This message will process both create + update request.
	SetValidatorSetPreference(ctx context.Context, in *MsgSetValidatorSetPreference, opts ...grpc.CallOption) (*MsgSetValidatorSetPreferenceResponse, error)
	// DelegateToValidatorSet gets the owner, coins and delegates to a
	// validator-set.
	DelegateToValidatorSet(ctx context.Context, in *MsgDelegateToValidatorSet, opts ...grpc.CallOption) (*MsgDelegateToValidatorSetResponse, error)
	// UndelegateFromValidatorSet gets the owner and coins and undelegates from
	// validator-set. The unbonding logic will follow the `Undelegate` logic from
	// the sdk.
	UndelegateFromValidatorSet(ctx context.Context, in *MsgUndelegateFromValidatorSet, opts ...grpc.CallOption) (*MsgUndelegateFromValidatorSetResponse, error)
	// UndelegateFromRebalancedValidatorSet undelegates the proivded amount from
	// the validator set, but takes into consideration the current delegations
	// to the user's validator set to determine the weights assigned to each.
	UndelegateFromRebalancedValidatorSet(ctx context.Context, in *MsgUndelegateFromRebalancedValidatorSet, opts ...grpc.CallOption) (*MsgUndelegateFromRebalancedValidatorSetResponse, error)
	// RedelegateValidatorSet takes the existing validator set and redelegates to
	// a new set.
	RedelegateValidatorSet(ctx context.Context, in *MsgRedelegateValidatorSet, opts ...grpc.CallOption) (*MsgRedelegateValidatorSetResponse, error)
	// WithdrawDelegationRewards allows users to claim rewards from the
	// validator-set.
	WithdrawDelegationRewards(ctx context.Context, in *MsgWithdrawDelegationRewards, opts ...grpc.CallOption) (*MsgWithdrawDelegationRewardsResponse, error)
	// DelegateBondedTokens allows users to break the lockup bond and delegate
	// osmo tokens to a predefined validator-set.
	DelegateBondedTokens(ctx context.Context, in *MsgDelegateBondedTokens, opts ...grpc.CallOption) (*MsgDelegateBondedTokensResponse, error)
}

type msgClient struct {
	cc grpc1.ClientConn
}

func NewMsgClient(cc grpc1.ClientConn) MsgClient {
	return &msgClient{cc}
}

func (c *msgClient) SetValidatorSetPreference(ctx context.Context, in *MsgSetValidatorSetPreference, opts ...grpc.CallOption) (*MsgSetValidatorSetPreferenceResponse, error) {
	out := new(MsgSetValidatorSetPreferenceResponse)
	err := c.cc.Invoke(ctx, "/osmosis.valsetpref.v1beta1.Msg/SetValidatorSetPreference", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) DelegateToValidatorSet(ctx context.Context, in *MsgDelegateToValidatorSet, opts ...grpc.CallOption) (*MsgDelegateToValidatorSetResponse, error) {
	out := new(MsgDelegateToValidatorSetResponse)
	err := c.cc.Invoke(ctx, "/osmosis.valsetpref.v1beta1.Msg/DelegateToValidatorSet", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) UndelegateFromValidatorSet(ctx context.Context, in *MsgUndelegateFromValidatorSet, opts ...grpc.CallOption) (*MsgUndelegateFromValidatorSetResponse, error) {
	out := new(MsgUndelegateFromValidatorSetResponse)
	err := c.cc.Invoke(ctx, "/osmosis.valsetpref.v1beta1.Msg/UndelegateFromValidatorSet", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) UndelegateFromRebalancedValidatorSet(ctx context.Context, in *MsgUndelegateFromRebalancedValidatorSet, opts ...grpc.CallOption) (*MsgUndelegateFromRebalancedValidatorSetResponse, error) {
	out := new(MsgUndelegateFromRebalancedValidatorSetResponse)
	err := c.cc.Invoke(ctx, "/osmosis.valsetpref.v1beta1.Msg/UndelegateFromRebalancedValidatorSet", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) RedelegateValidatorSet(ctx context.Context, in *MsgRedelegateValidatorSet, opts ...grpc.CallOption) (*MsgRedelegateValidatorSetResponse, error) {
	out := new(MsgRedelegateValidatorSetResponse)
	err := c.cc.Invoke(ctx, "/osmosis.valsetpref.v1beta1.Msg/RedelegateValidatorSet", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) WithdrawDelegationRewards(ctx context.Context, in *MsgWithdrawDelegationRewards, opts ...grpc.CallOption) (*MsgWithdrawDelegationRewardsResponse, error) {
	out := new(MsgWithdrawDelegationRewardsResponse)
	err := c.cc.Invoke(ctx, "/osmosis.valsetpref.v1beta1.Msg/WithdrawDelegationRewards", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) DelegateBondedTokens(ctx context.Context, in *MsgDelegateBondedTokens, opts ...grpc.CallOption) (*MsgDelegateBondedTokensResponse, error) {
	out := new(MsgDelegateBondedTokensResponse)
	err := c.cc.Invoke(ctx, "/osmosis.valsetpref.v1beta1.Msg/DelegateBondedTokens", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// MsgServer is the server API for Msg service.
type MsgServer interface {
	// SetValidatorSetPreference creates a set of validator preference.
	// This message will process both create + update request.
	SetValidatorSetPreference(context.Context, *MsgSetValidatorSetPreference) (*MsgSetValidatorSetPreferenceResponse, error)
	// DelegateToValidatorSet gets the owner, coins and delegates to a
	// validator-set.
	DelegateToValidatorSet(context.Context, *MsgDelegateToValidatorSet) (*MsgDelegateToValidatorSetResponse, error)
	// UndelegateFromValidatorSet gets the owner and coins and undelegates from
	// validator-set. The unbonding logic will follow the `Undelegate` logic from
	// the sdk.
	UndelegateFromValidatorSet(context.Context, *MsgUndelegateFromValidatorSet) (*MsgUndelegateFromValidatorSetResponse, error)
	// UndelegateFromRebalancedValidatorSet undelegates the proivded amount from
	// the validator set, but takes into consideration the current delegations
	// to the user's validator set to determine the weights assigned to each.
	UndelegateFromRebalancedValidatorSet(context.Context, *MsgUndelegateFromRebalancedValidatorSet) (*MsgUndelegateFromRebalancedValidatorSetResponse, error)
	// RedelegateValidatorSet takes the existing validator set and redelegates to
	// a new set.
	RedelegateValidatorSet(context.Context, *MsgRedelegateValidatorSet) (*MsgRedelegateValidatorSetResponse, error)
	// WithdrawDelegationRewards allows users to claim rewards from the
	// validator-set.
	WithdrawDelegationRewards(context.Context, *MsgWithdrawDelegationRewards) (*MsgWithdrawDelegationRewardsResponse, error)
	// DelegateBondedTokens allows users to break the lockup bond and delegate
	// osmo tokens to a predefined validator-set.
	DelegateBondedTokens(context.Context, *MsgDelegateBondedTokens) (*MsgDelegateBondedTokensResponse, error)
}

// UnimplementedMsgServer can be embedded to have forward compatible implementations.
type UnimplementedMsgServer struct {
}

func (*UnimplementedMsgServer) SetValidatorSetPreference(ctx context.Context, req *MsgSetValidatorSetPreference) (*MsgSetValidatorSetPreferenceResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetValidatorSetPreference not implemented")
}
func (*UnimplementedMsgServer) DelegateToValidatorSet(ctx context.Context, req *MsgDelegateToValidatorSet) (*MsgDelegateToValidatorSetResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DelegateToValidatorSet not implemented")
}
func (*UnimplementedMsgServer) UndelegateFromValidatorSet(ctx context.Context, req *MsgUndelegateFromValidatorSet) (*MsgUndelegateFromValidatorSetResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UndelegateFromValidatorSet not implemented")
}
func (*UnimplementedMsgServer) UndelegateFromRebalancedValidatorSet(ctx context.Context, req *MsgUndelegateFromRebalancedValidatorSet) (*MsgUndelegateFromRebalancedValidatorSetResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UndelegateFromRebalancedValidatorSet not implemented")
}
func (*UnimplementedMsgServer) RedelegateValidatorSet(ctx context.Context, req *MsgRedelegateValidatorSet) (*MsgRedelegateValidatorSetResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RedelegateValidatorSet not implemented")
}
func (*UnimplementedMsgServer) WithdrawDelegationRewards(ctx context.Context, req *MsgWithdrawDelegationRewards) (*MsgWithdrawDelegationRewardsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method WithdrawDelegationRewards not implemented")
}
func (*UnimplementedMsgServer) DelegateBondedTokens(ctx context.Context, req *MsgDelegateBondedTokens) (*MsgDelegateBondedTokensResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DelegateBondedTokens not implemented")
}

func RegisterMsgServer(s grpc1.Server, srv MsgServer) {
	s.RegisterService(&_Msg_serviceDesc, srv)
}

func _Msg_SetValidatorSetPreference_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgSetValidatorSetPreference)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).SetValidatorSetPreference(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/osmosis.valsetpref.v1beta1.Msg/SetValidatorSetPreference",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).SetValidatorSetPreference(ctx, req.(*MsgSetValidatorSetPreference))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_DelegateToValidatorSet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgDelegateToValidatorSet)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).DelegateToValidatorSet(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/osmosis.valsetpref.v1beta1.Msg/DelegateToValidatorSet",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).DelegateToValidatorSet(ctx, req.(*MsgDelegateToValidatorSet))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_UndelegateFromValidatorSet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgUndelegateFromValidatorSet)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).UndelegateFromValidatorSet(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/osmosis.valsetpref.v1beta1.Msg/UndelegateFromValidatorSet",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).UndelegateFromValidatorSet(ctx, req.(*MsgUndelegateFromValidatorSet))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_UndelegateFromRebalancedValidatorSet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgUndelegateFromRebalancedValidatorSet)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).UndelegateFromRebalancedValidatorSet(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/osmosis.valsetpref.v1beta1.Msg/UndelegateFromRebalancedValidatorSet",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).UndelegateFromRebalancedValidatorSet(ctx, req.(*MsgUndelegateFromRebalancedValidatorSet))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_RedelegateValidatorSet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgRedelegateValidatorSet)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).RedelegateValidatorSet(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/osmosis.valsetpref.v1beta1.Msg/RedelegateValidatorSet",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).RedelegateValidatorSet(ctx, req.(*MsgRedelegateValidatorSet))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_WithdrawDelegationRewards_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgWithdrawDelegationRewards)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).WithdrawDelegationRewards(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/osmosis.valsetpref.v1beta1.Msg/WithdrawDelegationRewards",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).WithdrawDelegationRewards(ctx, req.(*MsgWithdrawDelegationRewards))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_DelegateBondedTokens_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgDelegateBondedTokens)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).DelegateBondedTokens(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/osmosis.valsetpref.v1beta1.Msg/DelegateBondedTokens",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).DelegateBondedTokens(ctx, req.(*MsgDelegateBondedTokens))
	}
	return interceptor(ctx, in, info, handler)
}

var _Msg_serviceDesc = grpc.ServiceDesc{
	ServiceName: "osmosis.valsetpref.v1beta1.Msg",
	HandlerType: (*MsgServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "SetValidatorSetPreference",
			Handler:    _Msg_SetValidatorSetPreference_Handler,
		},
		{
			MethodName: "DelegateToValidatorSet",
			Handler:    _Msg_DelegateToValidatorSet_Handler,
		},
		{
			MethodName: "UndelegateFromValidatorSet",
			Handler:    _Msg_UndelegateFromValidatorSet_Handler,
		},
		{
			MethodName: "UndelegateFromRebalancedValidatorSet",
			Handler:    _Msg_UndelegateFromRebalancedValidatorSet_Handler,
		},
		{
			MethodName: "RedelegateValidatorSet",
			Handler:    _Msg_RedelegateValidatorSet_Handler,
		},
		{
			MethodName: "WithdrawDelegationRewards",
			Handler:    _Msg_WithdrawDelegationRewards_Handler,
		},
		{
			MethodName: "DelegateBondedTokens",
			Handler:    _Msg_DelegateBondedTokens_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "osmosis/valsetpref/v1beta1/tx.proto",
}

func (m *MsgSetValidatorSetPreference) 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 *MsgSetValidatorSetPreference) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgSetValidatorSetPreference) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Preferences) > 0 {
		for iNdEx := len(m.Preferences) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Preferences[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Delegator) > 0 {
		i -= len(m.Delegator)
		copy(dAtA[i:], m.Delegator)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Delegator)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MsgSetValidatorSetPreferenceResponse) 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 *MsgSetValidatorSetPreferenceResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgSetValidatorSetPreferenceResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *MsgDelegateToValidatorSet) 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 *MsgDelegateToValidatorSet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgDelegateToValidatorSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Coin.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.Delegator) > 0 {
		i -= len(m.Delegator)
		copy(dAtA[i:], m.Delegator)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Delegator)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MsgDelegateToValidatorSetResponse) 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 *MsgDelegateToValidatorSetResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgDelegateToValidatorSetResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *MsgUndelegateFromValidatorSet) 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 *MsgUndelegateFromValidatorSet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgUndelegateFromValidatorSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Coin.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if len(m.Delegator) > 0 {
		i -= len(m.Delegator)
		copy(dAtA[i:], m.Delegator)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Delegator)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MsgUndelegateFromValidatorSetResponse) 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 *MsgUndelegateFromValidatorSetResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgUndelegateFromValidatorSetResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *MsgUndelegateFromRebalancedValidatorSet) 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 *MsgUndelegateFromRebalancedValidatorSet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgUndelegateFromRebalancedValidatorSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Coin.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.Delegator) > 0 {
		i -= len(m.Delegator)
		copy(dAtA[i:], m.Delegator)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Delegator)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MsgUndelegateFromRebalancedValidatorSetResponse) 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 *MsgUndelegateFromRebalancedValidatorSetResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgUndelegateFromRebalancedValidatorSetResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *MsgRedelegateValidatorSet) 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 *MsgRedelegateValidatorSet) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgRedelegateValidatorSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Preferences) > 0 {
		for iNdEx := len(m.Preferences) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Preferences[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Delegator) > 0 {
		i -= len(m.Delegator)
		copy(dAtA[i:], m.Delegator)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Delegator)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MsgRedelegateValidatorSetResponse) 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 *MsgRedelegateValidatorSetResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgRedelegateValidatorSetResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *MsgWithdrawDelegationRewards) 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 *MsgWithdrawDelegationRewards) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgWithdrawDelegationRewards) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Delegator) > 0 {
		i -= len(m.Delegator)
		copy(dAtA[i:], m.Delegator)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Delegator)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MsgWithdrawDelegationRewardsResponse) 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 *MsgWithdrawDelegationRewardsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgWithdrawDelegationRewardsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *MsgDelegateBondedTokens) 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 *MsgDelegateBondedTokens) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgDelegateBondedTokens) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.LockID != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.LockID))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Delegator) > 0 {
		i -= len(m.Delegator)
		copy(dAtA[i:], m.Delegator)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Delegator)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MsgDelegateBondedTokensResponse) 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 *MsgDelegateBondedTokensResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MsgDelegateBondedTokensResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func encodeVarintTx(dAtA []byte, offset int, v uint64) int {
	offset -= sovTx(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *MsgSetValidatorSetPreference) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Delegator)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if len(m.Preferences) > 0 {
		for _, e := range m.Preferences {
			l = e.Size()
			n += 1 + l + sovTx(uint64(l))
		}
	}
	return n
}

func (m *MsgSetValidatorSetPreferenceResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *MsgDelegateToValidatorSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Delegator)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = m.Coin.Size()
	n += 1 + l + sovTx(uint64(l))
	return n
}

func (m *MsgDelegateToValidatorSetResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *MsgUndelegateFromValidatorSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Delegator)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = m.Coin.Size()
	n += 1 + l + sovTx(uint64(l))
	return n
}

func (m *MsgUndelegateFromValidatorSetResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *MsgUndelegateFromRebalancedValidatorSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Delegator)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = m.Coin.Size()
	n += 1 + l + sovTx(uint64(l))
	return n
}

func (m *MsgUndelegateFromRebalancedValidatorSetResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *MsgRedelegateValidatorSet) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Delegator)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if len(m.Preferences) > 0 {
		for _, e := range m.Preferences {
			l = e.Size()
			n += 1 + l + sovTx(uint64(l))
		}
	}
	return n
}

func (m *MsgRedelegateValidatorSetResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

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

func (m *MsgWithdrawDelegationRewardsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *MsgDelegateBondedTokens) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Delegator)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.LockID != 0 {
		n += 1 + sovTx(uint64(m.LockID))
	}
	return n
}

func (m *MsgDelegateBondedTokensResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func sovTx(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozTx(x uint64) (n int) {
	return sovTx(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *MsgSetValidatorSetPreference) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgSetValidatorSetPreference: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgSetValidatorSetPreference: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Delegator", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Delegator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Preferences", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Preferences = append(m.Preferences, ValidatorPreference{})
			if err := m.Preferences[len(m.Preferences)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgSetValidatorSetPreferenceResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgSetValidatorSetPreferenceResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgSetValidatorSetPreferenceResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgDelegateToValidatorSet) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgDelegateToValidatorSet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgDelegateToValidatorSet: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Delegator", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Delegator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Coin", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Coin.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgDelegateToValidatorSetResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgDelegateToValidatorSetResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgDelegateToValidatorSetResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgUndelegateFromValidatorSet) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgUndelegateFromValidatorSet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgUndelegateFromValidatorSet: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Delegator", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Delegator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Coin", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Coin.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgUndelegateFromValidatorSetResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgUndelegateFromValidatorSetResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgUndelegateFromValidatorSetResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgUndelegateFromRebalancedValidatorSet) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgUndelegateFromRebalancedValidatorSet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgUndelegateFromRebalancedValidatorSet: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Delegator", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Delegator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Coin", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Coin.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgUndelegateFromRebalancedValidatorSetResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgUndelegateFromRebalancedValidatorSetResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgUndelegateFromRebalancedValidatorSetResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgRedelegateValidatorSet) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgRedelegateValidatorSet: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgRedelegateValidatorSet: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Delegator", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Delegator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Preferences", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Preferences = append(m.Preferences, ValidatorPreference{})
			if err := m.Preferences[len(m.Preferences)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgRedelegateValidatorSetResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgRedelegateValidatorSetResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgRedelegateValidatorSetResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgWithdrawDelegationRewards) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgWithdrawDelegationRewards: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgWithdrawDelegationRewards: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Delegator", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Delegator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgWithdrawDelegationRewardsResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgWithdrawDelegationRewardsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgWithdrawDelegationRewardsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgDelegateBondedTokens) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgDelegateBondedTokens: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgDelegateBondedTokens: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Delegator", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Delegator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LockID", wireType)
			}
			m.LockID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LockID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgDelegateBondedTokensResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgDelegateBondedTokensResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgDelegateBondedTokensResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipTx(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowTx
			}
			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, ErrIntOverflowTx
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowTx
				}
				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, ErrInvalidLengthTx
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupTx
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthTx
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthTx        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowTx          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupTx = fmt.Errorf("proto: unexpected end of group")
)