tx.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: stride/stakeibc/tx.proto

package types

import (
	context "context"
	fmt "fmt"
	_ "github.com/cosmos/cosmos-proto"
	github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
	_ "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"
	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

type MsgLiquidStake struct {
	Creator   string                                 `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
	Amount    github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=amount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"amount"`
	HostDenom string                                 `protobuf:"bytes,3,opt,name=host_denom,json=hostDenom,proto3" json:"host_denom,omitempty"`
}

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

var xxx_messageInfo_MsgLiquidStake proto.InternalMessageInfo

func (m *MsgLiquidStake) GetCreator() string {
	if m != nil {
		return m.Creator
	}
	return ""
}

func (m *MsgLiquidStake) GetHostDenom() string {
	if m != nil {
		return m.HostDenom
	}
	return ""
}

type MsgLiquidStakeResponse struct {
}

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

var xxx_messageInfo_MsgLiquidStakeResponse proto.InternalMessageInfo

type MsgLSMLiquidStake struct {
	Creator          string                                 `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
	Amount           github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=amount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"amount"`
	LsmTokenIbcDenom string                                 `protobuf:"bytes,3,opt,name=lsm_token_ibc_denom,json=lsmTokenIbcDenom,proto3" json:"lsm_token_ibc_denom,omitempty"`
}

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

var xxx_messageInfo_MsgLSMLiquidStake proto.InternalMessageInfo

func (m *MsgLSMLiquidStake) GetCreator() string {
	if m != nil {
		return m.Creator
	}
	return ""
}

func (m *MsgLSMLiquidStake) GetLsmTokenIbcDenom() string {
	if m != nil {
		return m.LsmTokenIbcDenom
	}
	return ""
}

type MsgLSMLiquidStakeResponse struct {
	TransactionComplete bool `protobuf:"varint,1,opt,name=transaction_complete,json=transactionComplete,proto3" json:"transaction_complete,omitempty"`
}

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

var xxx_messageInfo_MsgLSMLiquidStakeResponse proto.InternalMessageInfo

func (m *MsgLSMLiquidStakeResponse) GetTransactionComplete() bool {
	if m != nil {
		return m.TransactionComplete
	}
	return false
}

type MsgClearBalance struct {
	Creator string                                 `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
	ChainId string                                 `protobuf:"bytes,2,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
	Amount  github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,3,opt,name=amount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"amount"`
	Channel string                                 `protobuf:"bytes,4,opt,name=channel,proto3" json:"channel,omitempty"`
}

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

var xxx_messageInfo_MsgClearBalance proto.InternalMessageInfo

func (m *MsgClearBalance) GetCreator() string {
	if m != nil {
		return m.Creator
	}
	return ""
}

func (m *MsgClearBalance) GetChainId() string {
	if m != nil {
		return m.ChainId
	}
	return ""
}

func (m *MsgClearBalance) GetChannel() string {
	if m != nil {
		return m.Channel
	}
	return ""
}

type MsgClearBalanceResponse struct {
}

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

var xxx_messageInfo_MsgClearBalanceResponse proto.InternalMessageInfo

type MsgRedeemStake struct {
	Creator  string                                 `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
	Amount   github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=amount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"amount"`
	HostZone string                                 `protobuf:"bytes,3,opt,name=host_zone,json=hostZone,proto3" json:"host_zone,omitempty"`
	Receiver string                                 `protobuf:"bytes,4,opt,name=receiver,proto3" json:"receiver,omitempty"`
}

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

var xxx_messageInfo_MsgRedeemStake proto.InternalMessageInfo

func (m *MsgRedeemStake) GetCreator() string {
	if m != nil {
		return m.Creator
	}
	return ""
}

func (m *MsgRedeemStake) GetHostZone() string {
	if m != nil {
		return m.HostZone
	}
	return ""
}

func (m *MsgRedeemStake) GetReceiver() string {
	if m != nil {
		return m.Receiver
	}
	return ""
}

type MsgRedeemStakeResponse struct {
}

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

var xxx_messageInfo_MsgRedeemStakeResponse proto.InternalMessageInfo

// next: 15
type MsgRegisterHostZone struct {
	ConnectionId          string                                 `protobuf:"bytes,2,opt,name=connection_id,json=connectionId,proto3" json:"connection_id,omitempty" yaml:"connection_id"`
	Bech32Prefix          string                                 `protobuf:"bytes,12,opt,name=bech32prefix,proto3" json:"bech32prefix,omitempty"`
	HostDenom             string                                 `protobuf:"bytes,4,opt,name=host_denom,json=hostDenom,proto3" json:"host_denom,omitempty" yaml:"host_denom"`
	IbcDenom              string                                 `protobuf:"bytes,5,opt,name=ibc_denom,json=ibcDenom,proto3" json:"ibc_denom,omitempty" yaml:"ibc_denom"`
	Creator               string                                 `protobuf:"bytes,6,opt,name=creator,proto3" json:"creator,omitempty"`
	TransferChannelId     string                                 `protobuf:"bytes,10,opt,name=transfer_channel_id,json=transferChannelId,proto3" json:"transfer_channel_id,omitempty" yaml:"transfer_channel_id"`
	UnbondingPeriod       uint64                                 `protobuf:"varint,11,opt,name=unbonding_period,json=unbondingPeriod,proto3" json:"unbonding_period,omitempty" yaml:"unbonding_period"`
	MinRedemptionRate     github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,13,opt,name=min_redemption_rate,json=minRedemptionRate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"min_redemption_rate"`
	MaxRedemptionRate     github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,14,opt,name=max_redemption_rate,json=maxRedemptionRate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"max_redemption_rate"`
	LsmLiquidStakeEnabled bool                                   `protobuf:"varint,15,opt,name=lsm_liquid_stake_enabled,json=lsmLiquidStakeEnabled,proto3" json:"lsm_liquid_stake_enabled,omitempty"`
}

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

var xxx_messageInfo_MsgRegisterHostZone proto.InternalMessageInfo

type MsgRegisterHostZoneResponse struct {
}

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

var xxx_messageInfo_MsgRegisterHostZoneResponse proto.InternalMessageInfo

type MsgClaimUndelegatedTokens struct {
	Creator string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
	// UserUnbondingRecords are keyed on {chain_id}.{epoch}.{sender}
	HostZoneId string `protobuf:"bytes,2,opt,name=host_zone_id,json=hostZoneId,proto3" json:"host_zone_id,omitempty"`
	Epoch      uint64 `protobuf:"varint,3,opt,name=epoch,proto3" json:"epoch,omitempty"`
	Sender     string `protobuf:"bytes,4,opt,name=sender,proto3" json:"sender,omitempty"`
}

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

var xxx_messageInfo_MsgClaimUndelegatedTokens proto.InternalMessageInfo

func (m *MsgClaimUndelegatedTokens) GetCreator() string {
	if m != nil {
		return m.Creator
	}
	return ""
}

func (m *MsgClaimUndelegatedTokens) GetHostZoneId() string {
	if m != nil {
		return m.HostZoneId
	}
	return ""
}

func (m *MsgClaimUndelegatedTokens) GetEpoch() uint64 {
	if m != nil {
		return m.Epoch
	}
	return 0
}

func (m *MsgClaimUndelegatedTokens) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

type MsgClaimUndelegatedTokensResponse struct {
}

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

var xxx_messageInfo_MsgClaimUndelegatedTokensResponse proto.InternalMessageInfo

type MsgRebalanceValidators struct {
	Creator      string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
	HostZone     string `protobuf:"bytes,2,opt,name=host_zone,json=hostZone,proto3" json:"host_zone,omitempty"`
	NumRebalance uint64 `protobuf:"varint,3,opt,name=num_rebalance,json=numRebalance,proto3" json:"num_rebalance,omitempty"`
}

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

var xxx_messageInfo_MsgRebalanceValidators proto.InternalMessageInfo

func (m *MsgRebalanceValidators) GetCreator() string {
	if m != nil {
		return m.Creator
	}
	return ""
}

func (m *MsgRebalanceValidators) GetHostZone() string {
	if m != nil {
		return m.HostZone
	}
	return ""
}

func (m *MsgRebalanceValidators) GetNumRebalance() uint64 {
	if m != nil {
		return m.NumRebalance
	}
	return 0
}

type MsgRebalanceValidatorsResponse struct {
}

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

var xxx_messageInfo_MsgRebalanceValidatorsResponse proto.InternalMessageInfo

type MsgAddValidators struct {
	Creator    string       `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
	HostZone   string       `protobuf:"bytes,2,opt,name=host_zone,json=hostZone,proto3" json:"host_zone,omitempty"`
	Validators []*Validator `protobuf:"bytes,3,rep,name=validators,proto3" json:"validators,omitempty"`
}

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

var xxx_messageInfo_MsgAddValidators proto.InternalMessageInfo

func (m *MsgAddValidators) GetCreator() string {
	if m != nil {
		return m.Creator
	}
	return ""
}

func (m *MsgAddValidators) GetHostZone() string {
	if m != nil {
		return m.HostZone
	}
	return ""
}

func (m *MsgAddValidators) GetValidators() []*Validator {
	if m != nil {
		return m.Validators
	}
	return nil
}

type MsgAddValidatorsResponse struct {
}

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

var xxx_messageInfo_MsgAddValidatorsResponse proto.InternalMessageInfo

type MsgChangeValidatorWeight struct {
	Creator  string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
	HostZone string `protobuf:"bytes,2,opt,name=host_zone,json=hostZone,proto3" json:"host_zone,omitempty"`
	ValAddr  string `protobuf:"bytes,3,opt,name=val_addr,json=valAddr,proto3" json:"val_addr,omitempty"`
	Weight   uint64 `protobuf:"varint,4,opt,name=weight,proto3" json:"weight,omitempty"`
}

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

var xxx_messageInfo_MsgChangeValidatorWeight proto.InternalMessageInfo

func (m *MsgChangeValidatorWeight) GetCreator() string {
	if m != nil {
		return m.Creator
	}
	return ""
}

func (m *MsgChangeValidatorWeight) GetHostZone() string {
	if m != nil {
		return m.HostZone
	}
	return ""
}

func (m *MsgChangeValidatorWeight) GetValAddr() string {
	if m != nil {
		return m.ValAddr
	}
	return ""
}

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

type MsgChangeValidatorWeightResponse struct {
}

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

var xxx_messageInfo_MsgChangeValidatorWeightResponse proto.InternalMessageInfo

type MsgDeleteValidator struct {
	Creator  string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
	HostZone string `protobuf:"bytes,2,opt,name=host_zone,json=hostZone,proto3" json:"host_zone,omitempty"`
	ValAddr  string `protobuf:"bytes,3,opt,name=val_addr,json=valAddr,proto3" json:"val_addr,omitempty"`
}

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

var xxx_messageInfo_MsgDeleteValidator proto.InternalMessageInfo

func (m *MsgDeleteValidator) GetCreator() string {
	if m != nil {
		return m.Creator
	}
	return ""
}

func (m *MsgDeleteValidator) GetHostZone() string {
	if m != nil {
		return m.HostZone
	}
	return ""
}

func (m *MsgDeleteValidator) GetValAddr() string {
	if m != nil {
		return m.ValAddr
	}
	return ""
}

type MsgDeleteValidatorResponse struct {
}

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

var xxx_messageInfo_MsgDeleteValidatorResponse proto.InternalMessageInfo

type MsgRestoreInterchainAccount struct {
	Creator     string         `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
	ChainId     string         `protobuf:"bytes,2,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
	AccountType ICAAccountType `protobuf:"varint,3,opt,name=account_type,json=accountType,proto3,enum=stride.stakeibc.ICAAccountType" json:"account_type,omitempty"`
}

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

var xxx_messageInfo_MsgRestoreInterchainAccount proto.InternalMessageInfo

func (m *MsgRestoreInterchainAccount) GetCreator() string {
	if m != nil {
		return m.Creator
	}
	return ""
}

func (m *MsgRestoreInterchainAccount) GetChainId() string {
	if m != nil {
		return m.ChainId
	}
	return ""
}

func (m *MsgRestoreInterchainAccount) GetAccountType() ICAAccountType {
	if m != nil {
		return m.AccountType
	}
	return ICAAccountType_DELEGATION
}

type MsgRestoreInterchainAccountResponse struct {
}

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

var xxx_messageInfo_MsgRestoreInterchainAccountResponse proto.InternalMessageInfo

type MsgUpdateValidatorSharesExchRate struct {
	Creator string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
	ChainId string `protobuf:"bytes,2,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
	Valoper string `protobuf:"bytes,3,opt,name=valoper,proto3" json:"valoper,omitempty"`
}

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

var xxx_messageInfo_MsgUpdateValidatorSharesExchRate proto.InternalMessageInfo

func (m *MsgUpdateValidatorSharesExchRate) GetCreator() string {
	if m != nil {
		return m.Creator
	}
	return ""
}

func (m *MsgUpdateValidatorSharesExchRate) GetChainId() string {
	if m != nil {
		return m.ChainId
	}
	return ""
}

func (m *MsgUpdateValidatorSharesExchRate) GetValoper() string {
	if m != nil {
		return m.Valoper
	}
	return ""
}

type MsgUpdateValidatorSharesExchRateResponse struct {
}

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

var xxx_messageInfo_MsgUpdateValidatorSharesExchRateResponse proto.InternalMessageInfo

func init() {
	proto.RegisterType((*MsgLiquidStake)(nil), "stride.stakeibc.MsgLiquidStake")
	proto.RegisterType((*MsgLiquidStakeResponse)(nil), "stride.stakeibc.MsgLiquidStakeResponse")
	proto.RegisterType((*MsgLSMLiquidStake)(nil), "stride.stakeibc.MsgLSMLiquidStake")
	proto.RegisterType((*MsgLSMLiquidStakeResponse)(nil), "stride.stakeibc.MsgLSMLiquidStakeResponse")
	proto.RegisterType((*MsgClearBalance)(nil), "stride.stakeibc.MsgClearBalance")
	proto.RegisterType((*MsgClearBalanceResponse)(nil), "stride.stakeibc.MsgClearBalanceResponse")
	proto.RegisterType((*MsgRedeemStake)(nil), "stride.stakeibc.MsgRedeemStake")
	proto.RegisterType((*MsgRedeemStakeResponse)(nil), "stride.stakeibc.MsgRedeemStakeResponse")
	proto.RegisterType((*MsgRegisterHostZone)(nil), "stride.stakeibc.MsgRegisterHostZone")
	proto.RegisterType((*MsgRegisterHostZoneResponse)(nil), "stride.stakeibc.MsgRegisterHostZoneResponse")
	proto.RegisterType((*MsgClaimUndelegatedTokens)(nil), "stride.stakeibc.MsgClaimUndelegatedTokens")
	proto.RegisterType((*MsgClaimUndelegatedTokensResponse)(nil), "stride.stakeibc.MsgClaimUndelegatedTokensResponse")
	proto.RegisterType((*MsgRebalanceValidators)(nil), "stride.stakeibc.MsgRebalanceValidators")
	proto.RegisterType((*MsgRebalanceValidatorsResponse)(nil), "stride.stakeibc.MsgRebalanceValidatorsResponse")
	proto.RegisterType((*MsgAddValidators)(nil), "stride.stakeibc.MsgAddValidators")
	proto.RegisterType((*MsgAddValidatorsResponse)(nil), "stride.stakeibc.MsgAddValidatorsResponse")
	proto.RegisterType((*MsgChangeValidatorWeight)(nil), "stride.stakeibc.MsgChangeValidatorWeight")
	proto.RegisterType((*MsgChangeValidatorWeightResponse)(nil), "stride.stakeibc.MsgChangeValidatorWeightResponse")
	proto.RegisterType((*MsgDeleteValidator)(nil), "stride.stakeibc.MsgDeleteValidator")
	proto.RegisterType((*MsgDeleteValidatorResponse)(nil), "stride.stakeibc.MsgDeleteValidatorResponse")
	proto.RegisterType((*MsgRestoreInterchainAccount)(nil), "stride.stakeibc.MsgRestoreInterchainAccount")
	proto.RegisterType((*MsgRestoreInterchainAccountResponse)(nil), "stride.stakeibc.MsgRestoreInterchainAccountResponse")
	proto.RegisterType((*MsgUpdateValidatorSharesExchRate)(nil), "stride.stakeibc.MsgUpdateValidatorSharesExchRate")
	proto.RegisterType((*MsgUpdateValidatorSharesExchRateResponse)(nil), "stride.stakeibc.MsgUpdateValidatorSharesExchRateResponse")
}

func init() { proto.RegisterFile("stride/stakeibc/tx.proto", fileDescriptor_9b7e09c9ad51cd54) }

var fileDescriptor_9b7e09c9ad51cd54 = []byte{
	// 1327 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x58, 0x4f, 0x6f, 0x1b, 0x45,
	0x14, 0xcf, 0x36, 0x69, 0xea, 0xbe, 0x38, 0xff, 0x36, 0x69, 0xbb, 0xd9, 0x52, 0xdb, 0xdd, 0xf0,
	0x27, 0x14, 0x62, 0x2b, 0x69, 0x25, 0x44, 0x05, 0x87, 0x38, 0x29, 0xc2, 0x52, 0x53, 0xa1, 0x4d,
	0x4b, 0xa5, 0x4a, 0x68, 0x19, 0xef, 0x4c, 0xd7, 0xab, 0xee, 0xce, 0xb8, 0x3b, 0xeb, 0xe0, 0x72,
	0x40, 0x5c, 0x90, 0xb8, 0x20, 0x81, 0x90, 0x38, 0xa2, 0x1e, 0x38, 0x20, 0x71, 0x43, 0xfd, 0x10,
	0x3d, 0x56, 0x3d, 0x21, 0x0e, 0x16, 0x6a, 0x2f, 0x9c, 0xf3, 0x09, 0xd0, 0xce, 0xae, 0xc7, 0xbb,
	0xf6, 0xc6, 0x49, 0x5b, 0xd4, 0x53, 0xfc, 0xe6, 0xfd, 0xe6, 0xbd, 0xdf, 0x7b, 0xf3, 0xe6, 0xcd,
	0xcb, 0x82, 0xc6, 0xc3, 0xc0, 0xc5, 0xa4, 0xc6, 0x43, 0x74, 0x8f, 0xb8, 0x4d, 0xbb, 0x16, 0x76,
	0xab, 0xed, 0x80, 0x85, 0x4c, 0x9d, 0x8f, 0x35, 0xd5, 0xbe, 0x46, 0xbf, 0x38, 0x0c, 0x75, 0x6d,
	0x64, 0x21, 0xdb, 0x66, 0x1d, 0x1a, 0xc6, 0x7b, 0xf4, 0xf2, 0x30, 0x64, 0x1f, 0x79, 0x2e, 0x46,
	0x21, 0x0b, 0x12, 0xc0, 0xb2, 0xc3, 0x1c, 0x26, 0x7e, 0xd6, 0xa2, 0x5f, 0xc9, 0xea, 0x8a, 0xcd,
	0xb8, 0xcf, 0xb8, 0x15, 0x2b, 0x62, 0x21, 0x56, 0x19, 0x3f, 0x29, 0x30, 0xb7, 0xcb, 0x9d, 0xeb,
	0xee, 0xfd, 0x8e, 0x8b, 0xf7, 0x22, 0xb3, 0xaa, 0x06, 0xa7, 0xec, 0x80, 0x44, 0x46, 0x35, 0xa5,
	0xa2, 0xac, 0x9d, 0x36, 0xfb, 0xa2, 0xfa, 0x09, 0x4c, 0x23, 0x3f, 0xa2, 0xa3, 0x9d, 0x88, 0x14,
	0xf5, 0xea, 0xe3, 0x5e, 0x79, 0xe2, 0xef, 0x5e, 0xf9, 0x6d, 0xc7, 0x0d, 0x5b, 0x9d, 0x66, 0xd5,
	0x66, 0x7e, 0x62, 0x3d, 0xf9, 0xb3, 0xce, 0xf1, 0xbd, 0x5a, 0xf8, 0xa0, 0x4d, 0x78, 0xb5, 0x41,
	0x43, 0x33, 0xd9, 0xad, 0x5e, 0x00, 0x68, 0x31, 0x1e, 0x5a, 0x98, 0x50, 0xe6, 0x6b, 0x93, 0xc2,
	0xc9, 0xe9, 0x68, 0x65, 0x27, 0x5a, 0x30, 0x34, 0x38, 0x9b, 0xa5, 0x64, 0x12, 0xde, 0x66, 0x94,
	0x13, 0xe3, 0x37, 0x05, 0x16, 0x23, 0xd5, 0xde, 0xee, 0xeb, 0x25, 0xbc, 0x0e, 0x4b, 0x1e, 0xf7,
	0xad, 0x90, 0xdd, 0x23, 0xd4, 0x72, 0x9b, 0x76, 0x86, 0xf9, 0x82, 0xc7, 0xfd, 0x9b, 0x91, 0xa6,
	0xd1, 0xb4, 0xe3, 0x00, 0x6e, 0xc0, 0xca, 0x08, 0xcb, 0x7e, 0x0c, 0xea, 0x06, 0x2c, 0x87, 0x01,
	0xa2, 0x1c, 0xd9, 0xa1, 0xcb, 0xa8, 0x65, 0x33, 0xbf, 0xed, 0x91, 0x90, 0x08, 0xea, 0x05, 0x73,
	0x29, 0xa5, 0xdb, 0x4e, 0x54, 0xc6, 0xef, 0x0a, 0xcc, 0xef, 0x72, 0x67, 0xdb, 0x23, 0x28, 0xa8,
	0x23, 0x0f, 0x51, 0x7b, 0x5c, 0xd0, 0x2b, 0x50, 0xb0, 0x5b, 0xc8, 0xa5, 0x96, 0x8b, 0xe3, 0xb0,
	0xcd, 0x53, 0x42, 0x6e, 0xe0, 0x54, 0x3e, 0x26, 0x5f, 0x29, 0x1f, 0x91, 0xf3, 0x16, 0xa2, 0x94,
	0x78, 0xda, 0x94, 0xf4, 0x10, 0x89, 0xc6, 0x0a, 0x9c, 0x1b, 0x62, 0x2a, 0x0f, 0xef, 0x8f, 0xb8,
	0xd4, 0x4c, 0x82, 0x09, 0xf1, 0x5f, 0xd7, 0xc9, 0x9d, 0x07, 0x51, 0x58, 0xd6, 0xd7, 0x8c, 0x92,
	0xe4, 0xbc, 0x0a, 0xd1, 0xc2, 0x1d, 0x46, 0x89, 0xaa, 0x43, 0x21, 0x20, 0x36, 0x71, 0xf7, 0x49,
	0x90, 0xc4, 0x21, 0xe5, 0xa4, 0x08, 0x53, 0x64, 0x65, 0x1c, 0x7f, 0x9e, 0x84, 0x25, 0xa1, 0x72,
	0x5c, 0x1e, 0x92, 0xe0, 0xd3, 0xbe, 0xb5, 0x8f, 0x61, 0xd6, 0x66, 0x94, 0x92, 0xf8, 0x5c, 0xfb,
	0xc9, 0xaf, 0x6b, 0x07, 0xbd, 0xf2, 0xf2, 0x03, 0xe4, 0x7b, 0x57, 0x8d, 0x8c, 0xda, 0x30, 0x8b,
	0x03, 0xb9, 0x81, 0x55, 0x03, 0x8a, 0x4d, 0x62, 0xb7, 0x2e, 0x6f, 0xb6, 0x03, 0x72, 0xd7, 0xed,
	0x6a, 0x45, 0x41, 0x28, 0xb3, 0xa6, 0x5e, 0xc9, 0x5c, 0x1c, 0x41, 0xb9, 0x7e, 0xe6, 0xa0, 0x57,
	0x5e, 0x8c, 0xed, 0x0f, 0x74, 0x46, 0xea, 0x3e, 0xa9, 0x1b, 0x70, 0x7a, 0x50, 0xb3, 0x27, 0xc5,
	0xa6, 0xe5, 0x83, 0x5e, 0x79, 0x21, 0xde, 0x24, 0x55, 0x86, 0x59, 0x70, 0x93, 0x0a, 0x4e, 0x1f,
	0xcc, 0x74, 0xf6, 0x60, 0x6e, 0x40, 0x5c, 0xa2, 0x77, 0x49, 0x60, 0x25, 0x87, 0x1e, 0xc5, 0x0a,
	0xc2, 0x6c, 0xe9, 0xa0, 0x57, 0xd6, 0x63, 0xb3, 0x39, 0x20, 0xc3, 0x5c, 0xec, 0xaf, 0x6e, 0xc7,
	0x8b, 0xa2, 0x24, 0x17, 0x3a, 0xb4, 0xc9, 0x28, 0x76, 0xa9, 0x63, 0xb5, 0x49, 0xe0, 0x32, 0xac,
	0xcd, 0x54, 0x94, 0xb5, 0xa9, 0xfa, 0xf9, 0x83, 0x5e, 0xf9, 0x5c, 0x6c, 0x6c, 0x18, 0x61, 0x98,
	0xf3, 0x72, 0xe9, 0x33, 0xb1, 0xa2, 0x7a, 0xb0, 0xe4, 0xbb, 0xd4, 0x0a, 0x08, 0x26, 0x7e, 0x5b,
	0xa4, 0x38, 0x40, 0x21, 0xd1, 0x66, 0x05, 0xaf, 0x8f, 0x5e, 0xa0, 0x7a, 0x76, 0x88, 0xfd, 0xf4,
	0xd1, 0x3a, 0x24, 0x5d, 0x72, 0x87, 0xd8, 0xe6, 0xa2, 0xef, 0x52, 0x53, 0xda, 0x35, 0x51, 0x48,
	0x84, 0x37, 0xd4, 0x1d, 0xf1, 0x36, 0xf7, 0xbf, 0x78, 0x43, 0xdd, 0x21, 0x6f, 0x1f, 0x80, 0x16,
	0xb5, 0x1f, 0x4f, 0x74, 0x13, 0x4b, 0x34, 0x7f, 0x8b, 0x50, 0xd4, 0xf4, 0x08, 0xd6, 0xe6, 0x45,
	0xdb, 0x38, 0xe3, 0x71, 0x3f, 0xd5, 0x6c, 0xae, 0xc5, 0xca, 0xab, 0x85, 0xef, 0x1f, 0x96, 0x27,
	0xfe, 0x7d, 0x58, 0x9e, 0x30, 0x2e, 0xc0, 0xf9, 0x9c, 0x9a, 0x95, 0x35, 0xfd, 0x9d, 0x22, 0x5a,
	0xd6, 0xb6, 0x87, 0x5c, 0xff, 0x16, 0xc5, 0xc4, 0x23, 0x0e, 0x0a, 0x09, 0x16, 0x6d, 0x8d, 0x8f,
	0xb9, 0xa6, 0x15, 0x28, 0xca, 0xeb, 0x35, 0xe8, 0x37, 0xd0, 0xbf, 0x61, 0x0d, 0xac, 0x2e, 0xc3,
	0x49, 0xd2, 0x66, 0x76, 0x4b, 0x5c, 0xbe, 0x29, 0x33, 0x16, 0xd4, 0xb3, 0x30, 0xcd, 0x09, 0xc5,
	0xf2, 0xde, 0x25, 0x92, 0xb1, 0x0a, 0x17, 0x0f, 0xa5, 0x21, 0xc9, 0x86, 0xc9, 0xd5, 0x6c, 0xc6,
	0x0d, 0xe6, 0xf3, 0xfe, 0x1b, 0x38, 0x8e, 0x68, 0xa6, 0x0f, 0x9c, 0x18, 0xea, 0x03, 0xab, 0x30,
	0x4b, 0x3b, 0xbe, 0x15, 0xf4, 0x2d, 0x26, 0x5c, 0x8b, 0xb4, 0xe3, 0x4b, 0x2f, 0x46, 0x05, 0x4a,
	0xf9, 0x5e, 0xd3, 0x49, 0x5c, 0xd8, 0xe5, 0xce, 0x16, 0xc6, 0xaf, 0x4e, 0xe9, 0x2a, 0x80, 0x7c,
	0xdb, 0xb9, 0x36, 0x59, 0x99, 0x5c, 0x9b, 0xd9, 0xd4, 0xab, 0x43, 0x23, 0x43, 0x55, 0xfa, 0x31,
	0x53, 0x68, 0x43, 0x07, 0x6d, 0x98, 0x86, 0xe4, 0xf8, 0xab, 0x22, 0x94, 0xd1, 0xfd, 0x73, 0x06,
	0x31, 0xdc, 0x26, 0xae, 0xd3, 0x0a, 0x5f, 0x96, 0xeb, 0x65, 0x28, 0xec, 0x23, 0xcf, 0x42, 0x18,
	0x07, 0xc9, 0xbb, 0xa2, 0x3d, 0x7d, 0xb4, 0xbe, 0x9c, 0xd4, 0xf4, 0x16, 0xc6, 0x01, 0xe1, 0x7c,
	0x2f, 0x0c, 0x5c, 0xea, 0x98, 0xa7, 0xf6, 0x91, 0x17, 0xad, 0x44, 0x15, 0xf0, 0x95, 0xf0, 0x2a,
	0x2a, 0x60, 0xca, 0x4c, 0x24, 0xc3, 0x80, 0xca, 0x61, 0xfc, 0x64, 0x10, 0xdf, 0x2a, 0xa0, 0xee,
	0x72, 0x67, 0x87, 0x44, 0xaf, 0xa3, 0x04, 0xbd, 0x4e, 0xfa, 0xc6, 0x1b, 0xa0, 0x8f, 0x32, 0x90,
	0x04, 0x7f, 0x51, 0x92, 0xeb, 0xc6, 0x43, 0x16, 0x90, 0x06, 0x0d, 0x49, 0x20, 0x9e, 0xe0, 0xad,
	0x78, 0x9a, 0x7b, 0xb9, 0xc7, 0xbb, 0x0e, 0xc5, 0x64, 0x1a, 0xb4, 0xa2, 0xde, 0x21, 0xb8, 0xce,
	0x6d, 0x96, 0x47, 0x8a, 0xa2, 0xb1, 0xbd, 0x95, 0xf8, 0xb9, 0xf9, 0xa0, 0x4d, 0xcc, 0x19, 0x34,
	0x10, 0x8c, 0xb7, 0x60, 0x75, 0x0c, 0x2f, 0xc9, 0xff, 0xbe, 0x38, 0x84, 0x5b, 0x6d, 0x8c, 0x52,
	0xd1, 0xed, 0xb5, 0x50, 0x40, 0xf8, 0xb5, 0xae, 0xdd, 0x12, 0x4d, 0xe9, 0xa5, 0x62, 0xd0, 0x20,
	0xca, 0x20, 0x6b, 0x93, 0x24, 0xd5, 0x66, 0x5f, 0x34, 0x2e, 0xc1, 0xda, 0x51, 0x2e, 0xfb, 0xf4,
	0x36, 0x7f, 0x06, 0x98, 0xdc, 0xe5, 0x8e, 0x7a, 0x1b, 0x66, 0xd2, 0x73, 0xe0, 0x68, 0x2a, 0xb2,
	0x63, 0xa4, 0xfe, 0xce, 0x11, 0x00, 0x39, 0xa3, 0x7d, 0x09, 0x73, 0x43, 0x33, 0xa6, 0x91, 0xbb,
	0x35, 0x83, 0xd1, 0x2f, 0x1d, 0x8d, 0x91, 0x1e, 0x6e, 0xc3, 0x4c, 0x7a, 0x10, 0xca, 0xa5, 0x9e,
	0x02, 0xe4, 0x53, 0xcf, 0x99, 0x4e, 0xd4, 0xbb, 0xb0, 0x30, 0x32, 0x99, 0xbc, 0x99, 0xbf, 0x39,
	0x8b, 0xd2, 0xdf, 0x3f, 0x0e, 0x4a, 0xfa, 0xe9, 0xc2, 0xd9, 0x43, 0x5e, 0x8b, 0xdc, 0x34, 0xe4,
	0x63, 0xf5, 0xcd, 0xe3, 0x63, 0xa5, 0x67, 0x06, 0x4b, 0x79, 0xbd, 0xff, 0x90, 0x0c, 0x8d, 0x00,
	0xf5, 0xda, 0x31, 0x81, 0xd2, 0xe1, 0x17, 0x30, 0x9b, 0xed, 0xe9, 0x17, 0xf3, 0x2c, 0x64, 0x20,
	0xfa, 0xbb, 0x47, 0x42, 0xa4, 0xf9, 0x0e, 0x9c, 0xc9, 0x6f, 0xc7, 0xb9, 0x36, 0x72, 0xa1, 0xfa,
	0xc6, 0xb1, 0xa1, 0xd2, 0xad, 0x0d, 0xf3, 0xc3, 0x0d, 0x74, 0x35, 0xcf, 0xca, 0x10, 0x48, 0x7f,
	0xef, 0x18, 0x20, 0xe9, 0xe4, 0x1b, 0xd0, 0x0e, 0x6d, 0x82, 0x87, 0xd4, 0x5b, 0x3e, 0x5a, 0xbf,
	0xf2, 0x22, 0x68, 0xe9, 0xff, 0x07, 0x05, 0x2e, 0x8c, 0x6f, 0x63, 0xb9, 0x99, 0x1b, 0xbb, 0x45,
	0xff, 0xf0, 0x85, 0xb7, 0x48, 0x3e, 0x77, 0xa0, 0x98, 0xf9, 0x2f, 0xae, 0x92, 0x5f, 0xff, 0x03,
	0x84, 0xbe, 0x76, 0x14, 0xa2, 0x6f, 0xbb, 0x7e, 0xfd, 0xf1, 0xb3, 0x92, 0xf2, 0xe4, 0x59, 0x49,
	0xf9, 0xe7, 0x59, 0x49, 0xf9, 0xf1, 0x79, 0x69, 0xe2, 0xc9, 0xf3, 0xd2, 0xc4, 0x5f, 0xcf, 0x4b,
	0x13, 0x77, 0x36, 0x53, 0x83, 0xe8, 0x9e, 0xb0, 0xb6, 0x7e, 0x1d, 0x35, 0x79, 0x2d, 0xf9, 0x9a,
	0xb0, 0xbf, 0x71, 0xa5, 0xd6, 0x4d, 0x7d, 0xa1, 0x88, 0x06, 0xd3, 0xe6, 0xb4, 0xf8, 0x3e, 0x70,
	0xf9, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xbc, 0xd4, 0x1b, 0x0b, 0xc1, 0x10, 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 {
	LiquidStake(ctx context.Context, in *MsgLiquidStake, opts ...grpc.CallOption) (*MsgLiquidStakeResponse, error)
	LSMLiquidStake(ctx context.Context, in *MsgLSMLiquidStake, opts ...grpc.CallOption) (*MsgLSMLiquidStakeResponse, error)
	RedeemStake(ctx context.Context, in *MsgRedeemStake, opts ...grpc.CallOption) (*MsgRedeemStakeResponse, error)
	RegisterHostZone(ctx context.Context, in *MsgRegisterHostZone, opts ...grpc.CallOption) (*MsgRegisterHostZoneResponse, error)
	ClaimUndelegatedTokens(ctx context.Context, in *MsgClaimUndelegatedTokens, opts ...grpc.CallOption) (*MsgClaimUndelegatedTokensResponse, error)
	RebalanceValidators(ctx context.Context, in *MsgRebalanceValidators, opts ...grpc.CallOption) (*MsgRebalanceValidatorsResponse, error)
	AddValidators(ctx context.Context, in *MsgAddValidators, opts ...grpc.CallOption) (*MsgAddValidatorsResponse, error)
	ChangeValidatorWeight(ctx context.Context, in *MsgChangeValidatorWeight, opts ...grpc.CallOption) (*MsgChangeValidatorWeightResponse, error)
	DeleteValidator(ctx context.Context, in *MsgDeleteValidator, opts ...grpc.CallOption) (*MsgDeleteValidatorResponse, error)
	RestoreInterchainAccount(ctx context.Context, in *MsgRestoreInterchainAccount, opts ...grpc.CallOption) (*MsgRestoreInterchainAccountResponse, error)
	UpdateValidatorSharesExchRate(ctx context.Context, in *MsgUpdateValidatorSharesExchRate, opts ...grpc.CallOption) (*MsgUpdateValidatorSharesExchRateResponse, error)
	ClearBalance(ctx context.Context, in *MsgClearBalance, opts ...grpc.CallOption) (*MsgClearBalanceResponse, error)
}

type msgClient struct {
	cc grpc1.ClientConn
}

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

func (c *msgClient) LiquidStake(ctx context.Context, in *MsgLiquidStake, opts ...grpc.CallOption) (*MsgLiquidStakeResponse, error) {
	out := new(MsgLiquidStakeResponse)
	err := c.cc.Invoke(ctx, "/stride.stakeibc.Msg/LiquidStake", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) LSMLiquidStake(ctx context.Context, in *MsgLSMLiquidStake, opts ...grpc.CallOption) (*MsgLSMLiquidStakeResponse, error) {
	out := new(MsgLSMLiquidStakeResponse)
	err := c.cc.Invoke(ctx, "/stride.stakeibc.Msg/LSMLiquidStake", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) RedeemStake(ctx context.Context, in *MsgRedeemStake, opts ...grpc.CallOption) (*MsgRedeemStakeResponse, error) {
	out := new(MsgRedeemStakeResponse)
	err := c.cc.Invoke(ctx, "/stride.stakeibc.Msg/RedeemStake", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) RegisterHostZone(ctx context.Context, in *MsgRegisterHostZone, opts ...grpc.CallOption) (*MsgRegisterHostZoneResponse, error) {
	out := new(MsgRegisterHostZoneResponse)
	err := c.cc.Invoke(ctx, "/stride.stakeibc.Msg/RegisterHostZone", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) ClaimUndelegatedTokens(ctx context.Context, in *MsgClaimUndelegatedTokens, opts ...grpc.CallOption) (*MsgClaimUndelegatedTokensResponse, error) {
	out := new(MsgClaimUndelegatedTokensResponse)
	err := c.cc.Invoke(ctx, "/stride.stakeibc.Msg/ClaimUndelegatedTokens", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) RebalanceValidators(ctx context.Context, in *MsgRebalanceValidators, opts ...grpc.CallOption) (*MsgRebalanceValidatorsResponse, error) {
	out := new(MsgRebalanceValidatorsResponse)
	err := c.cc.Invoke(ctx, "/stride.stakeibc.Msg/RebalanceValidators", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) AddValidators(ctx context.Context, in *MsgAddValidators, opts ...grpc.CallOption) (*MsgAddValidatorsResponse, error) {
	out := new(MsgAddValidatorsResponse)
	err := c.cc.Invoke(ctx, "/stride.stakeibc.Msg/AddValidators", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) ChangeValidatorWeight(ctx context.Context, in *MsgChangeValidatorWeight, opts ...grpc.CallOption) (*MsgChangeValidatorWeightResponse, error) {
	out := new(MsgChangeValidatorWeightResponse)
	err := c.cc.Invoke(ctx, "/stride.stakeibc.Msg/ChangeValidatorWeight", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) DeleteValidator(ctx context.Context, in *MsgDeleteValidator, opts ...grpc.CallOption) (*MsgDeleteValidatorResponse, error) {
	out := new(MsgDeleteValidatorResponse)
	err := c.cc.Invoke(ctx, "/stride.stakeibc.Msg/DeleteValidator", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) RestoreInterchainAccount(ctx context.Context, in *MsgRestoreInterchainAccount, opts ...grpc.CallOption) (*MsgRestoreInterchainAccountResponse, error) {
	out := new(MsgRestoreInterchainAccountResponse)
	err := c.cc.Invoke(ctx, "/stride.stakeibc.Msg/RestoreInterchainAccount", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) UpdateValidatorSharesExchRate(ctx context.Context, in *MsgUpdateValidatorSharesExchRate, opts ...grpc.CallOption) (*MsgUpdateValidatorSharesExchRateResponse, error) {
	out := new(MsgUpdateValidatorSharesExchRateResponse)
	err := c.cc.Invoke(ctx, "/stride.stakeibc.Msg/UpdateValidatorSharesExchRate", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) ClearBalance(ctx context.Context, in *MsgClearBalance, opts ...grpc.CallOption) (*MsgClearBalanceResponse, error) {
	out := new(MsgClearBalanceResponse)
	err := c.cc.Invoke(ctx, "/stride.stakeibc.Msg/ClearBalance", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// MsgServer is the server API for Msg service.
type MsgServer interface {
	LiquidStake(context.Context, *MsgLiquidStake) (*MsgLiquidStakeResponse, error)
	LSMLiquidStake(context.Context, *MsgLSMLiquidStake) (*MsgLSMLiquidStakeResponse, error)
	RedeemStake(context.Context, *MsgRedeemStake) (*MsgRedeemStakeResponse, error)
	RegisterHostZone(context.Context, *MsgRegisterHostZone) (*MsgRegisterHostZoneResponse, error)
	ClaimUndelegatedTokens(context.Context, *MsgClaimUndelegatedTokens) (*MsgClaimUndelegatedTokensResponse, error)
	RebalanceValidators(context.Context, *MsgRebalanceValidators) (*MsgRebalanceValidatorsResponse, error)
	AddValidators(context.Context, *MsgAddValidators) (*MsgAddValidatorsResponse, error)
	ChangeValidatorWeight(context.Context, *MsgChangeValidatorWeight) (*MsgChangeValidatorWeightResponse, error)
	DeleteValidator(context.Context, *MsgDeleteValidator) (*MsgDeleteValidatorResponse, error)
	RestoreInterchainAccount(context.Context, *MsgRestoreInterchainAccount) (*MsgRestoreInterchainAccountResponse, error)
	UpdateValidatorSharesExchRate(context.Context, *MsgUpdateValidatorSharesExchRate) (*MsgUpdateValidatorSharesExchRateResponse, error)
	ClearBalance(context.Context, *MsgClearBalance) (*MsgClearBalanceResponse, error)
}

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

func (*UnimplementedMsgServer) LiquidStake(ctx context.Context, req *MsgLiquidStake) (*MsgLiquidStakeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method LiquidStake not implemented")
}
func (*UnimplementedMsgServer) LSMLiquidStake(ctx context.Context, req *MsgLSMLiquidStake) (*MsgLSMLiquidStakeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method LSMLiquidStake not implemented")
}
func (*UnimplementedMsgServer) RedeemStake(ctx context.Context, req *MsgRedeemStake) (*MsgRedeemStakeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RedeemStake not implemented")
}
func (*UnimplementedMsgServer) RegisterHostZone(ctx context.Context, req *MsgRegisterHostZone) (*MsgRegisterHostZoneResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RegisterHostZone not implemented")
}
func (*UnimplementedMsgServer) ClaimUndelegatedTokens(ctx context.Context, req *MsgClaimUndelegatedTokens) (*MsgClaimUndelegatedTokensResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ClaimUndelegatedTokens not implemented")
}
func (*UnimplementedMsgServer) RebalanceValidators(ctx context.Context, req *MsgRebalanceValidators) (*MsgRebalanceValidatorsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RebalanceValidators not implemented")
}
func (*UnimplementedMsgServer) AddValidators(ctx context.Context, req *MsgAddValidators) (*MsgAddValidatorsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddValidators not implemented")
}
func (*UnimplementedMsgServer) ChangeValidatorWeight(ctx context.Context, req *MsgChangeValidatorWeight) (*MsgChangeValidatorWeightResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ChangeValidatorWeight not implemented")
}
func (*UnimplementedMsgServer) DeleteValidator(ctx context.Context, req *MsgDeleteValidator) (*MsgDeleteValidatorResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteValidator not implemented")
}
func (*UnimplementedMsgServer) RestoreInterchainAccount(ctx context.Context, req *MsgRestoreInterchainAccount) (*MsgRestoreInterchainAccountResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RestoreInterchainAccount not implemented")
}
func (*UnimplementedMsgServer) UpdateValidatorSharesExchRate(ctx context.Context, req *MsgUpdateValidatorSharesExchRate) (*MsgUpdateValidatorSharesExchRateResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateValidatorSharesExchRate not implemented")
}
func (*UnimplementedMsgServer) ClearBalance(ctx context.Context, req *MsgClearBalance) (*MsgClearBalanceResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ClearBalance not implemented")
}

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

func _Msg_LiquidStake_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgLiquidStake)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).LiquidStake(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/stride.stakeibc.Msg/LiquidStake",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).LiquidStake(ctx, req.(*MsgLiquidStake))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_LSMLiquidStake_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgLSMLiquidStake)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).LSMLiquidStake(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/stride.stakeibc.Msg/LSMLiquidStake",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).LSMLiquidStake(ctx, req.(*MsgLSMLiquidStake))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_RedeemStake_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgRedeemStake)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).RedeemStake(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/stride.stakeibc.Msg/RedeemStake",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).RedeemStake(ctx, req.(*MsgRedeemStake))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_RegisterHostZone_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgRegisterHostZone)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).RegisterHostZone(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/stride.stakeibc.Msg/RegisterHostZone",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).RegisterHostZone(ctx, req.(*MsgRegisterHostZone))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_ClaimUndelegatedTokens_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgClaimUndelegatedTokens)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).ClaimUndelegatedTokens(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/stride.stakeibc.Msg/ClaimUndelegatedTokens",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).ClaimUndelegatedTokens(ctx, req.(*MsgClaimUndelegatedTokens))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_RebalanceValidators_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgRebalanceValidators)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).RebalanceValidators(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/stride.stakeibc.Msg/RebalanceValidators",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).RebalanceValidators(ctx, req.(*MsgRebalanceValidators))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_AddValidators_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgAddValidators)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).AddValidators(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/stride.stakeibc.Msg/AddValidators",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).AddValidators(ctx, req.(*MsgAddValidators))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_ChangeValidatorWeight_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgChangeValidatorWeight)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).ChangeValidatorWeight(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/stride.stakeibc.Msg/ChangeValidatorWeight",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).ChangeValidatorWeight(ctx, req.(*MsgChangeValidatorWeight))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_DeleteValidator_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgDeleteValidator)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).DeleteValidator(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/stride.stakeibc.Msg/DeleteValidator",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).DeleteValidator(ctx, req.(*MsgDeleteValidator))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_RestoreInterchainAccount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgRestoreInterchainAccount)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).RestoreInterchainAccount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/stride.stakeibc.Msg/RestoreInterchainAccount",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).RestoreInterchainAccount(ctx, req.(*MsgRestoreInterchainAccount))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_UpdateValidatorSharesExchRate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgUpdateValidatorSharesExchRate)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).UpdateValidatorSharesExchRate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/stride.stakeibc.Msg/UpdateValidatorSharesExchRate",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).UpdateValidatorSharesExchRate(ctx, req.(*MsgUpdateValidatorSharesExchRate))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_ClearBalance_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgClearBalance)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).ClearBalance(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/stride.stakeibc.Msg/ClearBalance",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).ClearBalance(ctx, req.(*MsgClearBalance))
	}
	return interceptor(ctx, in, info, handler)
}

var _Msg_serviceDesc = grpc.ServiceDesc{
	ServiceName: "stride.stakeibc.Msg",
	HandlerType: (*MsgServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "LiquidStake",
			Handler:    _Msg_LiquidStake_Handler,
		},
		{
			MethodName: "LSMLiquidStake",
			Handler:    _Msg_LSMLiquidStake_Handler,
		},
		{
			MethodName: "RedeemStake",
			Handler:    _Msg_RedeemStake_Handler,
		},
		{
			MethodName: "RegisterHostZone",
			Handler:    _Msg_RegisterHostZone_Handler,
		},
		{
			MethodName: "ClaimUndelegatedTokens",
			Handler:    _Msg_ClaimUndelegatedTokens_Handler,
		},
		{
			MethodName: "RebalanceValidators",
			Handler:    _Msg_RebalanceValidators_Handler,
		},
		{
			MethodName: "AddValidators",
			Handler:    _Msg_AddValidators_Handler,
		},
		{
			MethodName: "ChangeValidatorWeight",
			Handler:    _Msg_ChangeValidatorWeight_Handler,
		},
		{
			MethodName: "DeleteValidator",
			Handler:    _Msg_DeleteValidator_Handler,
		},
		{
			MethodName: "RestoreInterchainAccount",
			Handler:    _Msg_RestoreInterchainAccount_Handler,
		},
		{
			MethodName: "UpdateValidatorSharesExchRate",
			Handler:    _Msg_UpdateValidatorSharesExchRate_Handler,
		},
		{
			MethodName: "ClearBalance",
			Handler:    _Msg_ClearBalance_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "stride/stakeibc/tx.proto",
}

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

func (m *MsgLiquidStake) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.HostDenom) > 0 {
		i -= len(m.HostDenom)
		copy(dAtA[i:], m.HostDenom)
		i = encodeVarintTx(dAtA, i, uint64(len(m.HostDenom)))
		i--
		dAtA[i] = 0x1a
	}
	{
		size := m.Amount.Size()
		i -= size
		if _, err := m.Amount.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.Creator) > 0 {
		i -= len(m.Creator)
		copy(dAtA[i:], m.Creator)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Creator)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgLSMLiquidStake) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.LsmTokenIbcDenom) > 0 {
		i -= len(m.LsmTokenIbcDenom)
		copy(dAtA[i:], m.LsmTokenIbcDenom)
		i = encodeVarintTx(dAtA, i, uint64(len(m.LsmTokenIbcDenom)))
		i--
		dAtA[i] = 0x1a
	}
	{
		size := m.Amount.Size()
		i -= size
		if _, err := m.Amount.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.Creator) > 0 {
		i -= len(m.Creator)
		copy(dAtA[i:], m.Creator)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Creator)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *MsgLSMLiquidStakeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TransactionComplete {
		i--
		if m.TransactionComplete {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *MsgClearBalance) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Channel) > 0 {
		i -= len(m.Channel)
		copy(dAtA[i:], m.Channel)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Channel)))
		i--
		dAtA[i] = 0x22
	}
	{
		size := m.Amount.Size()
		i -= size
		if _, err := m.Amount.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if len(m.ChainId) > 0 {
		i -= len(m.ChainId)
		copy(dAtA[i:], m.ChainId)
		i = encodeVarintTx(dAtA, i, uint64(len(m.ChainId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Creator) > 0 {
		i -= len(m.Creator)
		copy(dAtA[i:], m.Creator)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Creator)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgRedeemStake) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Receiver) > 0 {
		i -= len(m.Receiver)
		copy(dAtA[i:], m.Receiver)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Receiver)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.HostZone) > 0 {
		i -= len(m.HostZone)
		copy(dAtA[i:], m.HostZone)
		i = encodeVarintTx(dAtA, i, uint64(len(m.HostZone)))
		i--
		dAtA[i] = 0x1a
	}
	{
		size := m.Amount.Size()
		i -= size
		if _, err := m.Amount.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.Creator) > 0 {
		i -= len(m.Creator)
		copy(dAtA[i:], m.Creator)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Creator)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgRegisterHostZone) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.LsmLiquidStakeEnabled {
		i--
		if m.LsmLiquidStakeEnabled {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x78
	}
	{
		size := m.MaxRedemptionRate.Size()
		i -= size
		if _, err := m.MaxRedemptionRate.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x72
	{
		size := m.MinRedemptionRate.Size()
		i -= size
		if _, err := m.MinRedemptionRate.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x6a
	if len(m.Bech32Prefix) > 0 {
		i -= len(m.Bech32Prefix)
		copy(dAtA[i:], m.Bech32Prefix)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Bech32Prefix)))
		i--
		dAtA[i] = 0x62
	}
	if m.UnbondingPeriod != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.UnbondingPeriod))
		i--
		dAtA[i] = 0x58
	}
	if len(m.TransferChannelId) > 0 {
		i -= len(m.TransferChannelId)
		copy(dAtA[i:], m.TransferChannelId)
		i = encodeVarintTx(dAtA, i, uint64(len(m.TransferChannelId)))
		i--
		dAtA[i] = 0x52
	}
	if len(m.Creator) > 0 {
		i -= len(m.Creator)
		copy(dAtA[i:], m.Creator)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Creator)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.IbcDenom) > 0 {
		i -= len(m.IbcDenom)
		copy(dAtA[i:], m.IbcDenom)
		i = encodeVarintTx(dAtA, i, uint64(len(m.IbcDenom)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.HostDenom) > 0 {
		i -= len(m.HostDenom)
		copy(dAtA[i:], m.HostDenom)
		i = encodeVarintTx(dAtA, i, uint64(len(m.HostDenom)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.ConnectionId) > 0 {
		i -= len(m.ConnectionId)
		copy(dAtA[i:], m.ConnectionId)
		i = encodeVarintTx(dAtA, i, uint64(len(m.ConnectionId)))
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgClaimUndelegatedTokens) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0x22
	}
	if m.Epoch != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.Epoch))
		i--
		dAtA[i] = 0x18
	}
	if len(m.HostZoneId) > 0 {
		i -= len(m.HostZoneId)
		copy(dAtA[i:], m.HostZoneId)
		i = encodeVarintTx(dAtA, i, uint64(len(m.HostZoneId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Creator) > 0 {
		i -= len(m.Creator)
		copy(dAtA[i:], m.Creator)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Creator)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgRebalanceValidators) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.NumRebalance != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.NumRebalance))
		i--
		dAtA[i] = 0x18
	}
	if len(m.HostZone) > 0 {
		i -= len(m.HostZone)
		copy(dAtA[i:], m.HostZone)
		i = encodeVarintTx(dAtA, i, uint64(len(m.HostZone)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Creator) > 0 {
		i -= len(m.Creator)
		copy(dAtA[i:], m.Creator)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Creator)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

func (m *MsgChangeValidatorWeight) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Weight != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.Weight))
		i--
		dAtA[i] = 0x20
	}
	if len(m.ValAddr) > 0 {
		i -= len(m.ValAddr)
		copy(dAtA[i:], m.ValAddr)
		i = encodeVarintTx(dAtA, i, uint64(len(m.ValAddr)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.HostZone) > 0 {
		i -= len(m.HostZone)
		copy(dAtA[i:], m.HostZone)
		i = encodeVarintTx(dAtA, i, uint64(len(m.HostZone)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Creator) > 0 {
		i -= len(m.Creator)
		copy(dAtA[i:], m.Creator)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Creator)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

func (m *MsgRestoreInterchainAccount) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.AccountType != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.AccountType))
		i--
		dAtA[i] = 0x18
	}
	if len(m.ChainId) > 0 {
		i -= len(m.ChainId)
		copy(dAtA[i:], m.ChainId)
		i = encodeVarintTx(dAtA, i, uint64(len(m.ChainId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Creator) > 0 {
		i -= len(m.Creator)
		copy(dAtA[i:], m.Creator)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Creator)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *MsgUpdateValidatorSharesExchRateResponse) 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 *MsgLiquidStake) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Creator)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = m.Amount.Size()
	n += 1 + l + sovTx(uint64(l))
	l = len(m.HostDenom)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

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

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

func (m *MsgLSMLiquidStakeResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TransactionComplete {
		n += 2
	}
	return n
}

func (m *MsgClearBalance) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Creator)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.ChainId)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = m.Amount.Size()
	n += 1 + l + sovTx(uint64(l))
	l = len(m.Channel)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

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

func (m *MsgRedeemStake) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Creator)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = m.Amount.Size()
	n += 1 + l + sovTx(uint64(l))
	l = len(m.HostZone)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Receiver)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

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

func (m *MsgRegisterHostZone) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ConnectionId)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.HostDenom)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.IbcDenom)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Creator)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.TransferChannelId)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.UnbondingPeriod != 0 {
		n += 1 + sovTx(uint64(m.UnbondingPeriod))
	}
	l = len(m.Bech32Prefix)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = m.MinRedemptionRate.Size()
	n += 1 + l + sovTx(uint64(l))
	l = m.MaxRedemptionRate.Size()
	n += 1 + l + sovTx(uint64(l))
	if m.LsmLiquidStakeEnabled {
		n += 2
	}
	return n
}

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

func (m *MsgClaimUndelegatedTokens) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Creator)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.HostZoneId)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.Epoch != 0 {
		n += 1 + sovTx(uint64(m.Epoch))
	}
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

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

func (m *MsgRebalanceValidators) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Creator)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.HostZone)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.NumRebalance != 0 {
		n += 1 + sovTx(uint64(m.NumRebalance))
	}
	return n
}

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

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

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

func (m *MsgChangeValidatorWeight) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Creator)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.HostZone)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.ValAddr)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.Weight != 0 {
		n += 1 + sovTx(uint64(m.Weight))
	}
	return n
}

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

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

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

func (m *MsgRestoreInterchainAccount) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Creator)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.ChainId)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.AccountType != 0 {
		n += 1 + sovTx(uint64(m.AccountType))
	}
	return n
}

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

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

func (m *MsgUpdateValidatorSharesExchRateResponse) 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 *MsgLiquidStake) 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: MsgLiquidStake: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgLiquidStake: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", 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.Creator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", 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
			}
			if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HostDenom", 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.HostDenom = 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 *MsgLiquidStakeResponse) 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: MsgLiquidStakeResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgLiquidStakeResponse: 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 *MsgLSMLiquidStake) 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: MsgLSMLiquidStake: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgLSMLiquidStake: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", 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.Creator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", 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
			}
			if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LsmTokenIbcDenom", 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.LsmTokenIbcDenom = 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 *MsgLSMLiquidStakeResponse) 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: MsgLSMLiquidStakeResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgLSMLiquidStakeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TransactionComplete", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.TransactionComplete = bool(v != 0)
		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 *MsgClearBalance) 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: MsgClearBalance: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgClearBalance: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", 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.Creator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChainId", 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.ChainId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", 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
			}
			if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Channel", 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.Channel = 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 *MsgClearBalanceResponse) 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: MsgClearBalanceResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgClearBalanceResponse: 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 *MsgRedeemStake) 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: MsgRedeemStake: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgRedeemStake: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", 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.Creator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", 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
			}
			if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HostZone", 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.HostZone = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Receiver", 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.Receiver = 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 *MsgRedeemStakeResponse) 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: MsgRedeemStakeResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgRedeemStakeResponse: 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 *MsgRegisterHostZone) 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: MsgRegisterHostZone: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgRegisterHostZone: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConnectionId", 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.ConnectionId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HostDenom", 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.HostDenom = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IbcDenom", 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.IbcDenom = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", 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.Creator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TransferChannelId", 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.TransferChannelId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UnbondingPeriod", wireType)
			}
			m.UnbondingPeriod = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UnbondingPeriod |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Bech32Prefix", 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.Bech32Prefix = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinRedemptionRate", 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
			}
			if err := m.MinRedemptionRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxRedemptionRate", 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
			}
			if err := m.MaxRedemptionRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 15:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LsmLiquidStakeEnabled", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.LsmLiquidStakeEnabled = bool(v != 0)
		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 *MsgRegisterHostZoneResponse) 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: MsgRegisterHostZoneResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgRegisterHostZoneResponse: 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 *MsgClaimUndelegatedTokens) 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: MsgClaimUndelegatedTokens: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgClaimUndelegatedTokens: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", 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.Creator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HostZoneId", 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.HostZoneId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType)
			}
			m.Epoch = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Epoch |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", 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.Sender = 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 *MsgClaimUndelegatedTokensResponse) 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: MsgClaimUndelegatedTokensResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgClaimUndelegatedTokensResponse: 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 *MsgRebalanceValidators) 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: MsgRebalanceValidators: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgRebalanceValidators: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", 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.Creator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HostZone", 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.HostZone = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NumRebalance", wireType)
			}
			m.NumRebalance = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NumRebalance |= 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 *MsgRebalanceValidatorsResponse) 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: MsgRebalanceValidatorsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgRebalanceValidatorsResponse: 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 *MsgAddValidators) 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: MsgAddValidators: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgAddValidators: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", 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.Creator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HostZone", 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.HostZone = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Validators", 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.Validators = append(m.Validators, &Validator{})
			if err := m.Validators[len(m.Validators)-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 *MsgAddValidatorsResponse) 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: MsgAddValidatorsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgAddValidatorsResponse: 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 *MsgChangeValidatorWeight) 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: MsgChangeValidatorWeight: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgChangeValidatorWeight: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", 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.Creator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HostZone", 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.HostZone = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValAddr", 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.ValAddr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			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 ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Weight |= 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 *MsgChangeValidatorWeightResponse) 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: MsgChangeValidatorWeightResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgChangeValidatorWeightResponse: 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 *MsgDeleteValidator) 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: MsgDeleteValidator: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgDeleteValidator: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", 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.Creator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HostZone", 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.HostZone = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValAddr", 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.ValAddr = 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 *MsgDeleteValidatorResponse) 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: MsgDeleteValidatorResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgDeleteValidatorResponse: 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 *MsgRestoreInterchainAccount) 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: MsgRestoreInterchainAccount: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgRestoreInterchainAccount: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", 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.Creator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChainId", 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.ChainId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccountType", wireType)
			}
			m.AccountType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AccountType |= ICAAccountType(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 *MsgRestoreInterchainAccountResponse) 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: MsgRestoreInterchainAccountResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgRestoreInterchainAccountResponse: 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 *MsgUpdateValidatorSharesExchRate) 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: MsgUpdateValidatorSharesExchRate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgUpdateValidatorSharesExchRate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", 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.Creator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChainId", 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.ChainId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Valoper", 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.Valoper = 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 *MsgUpdateValidatorSharesExchRateResponse) 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: MsgUpdateValidatorSharesExchRateResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgUpdateValidatorSharesExchRateResponse: 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")
)