lscosmos.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: pstake/lscosmos/v1beta1/lscosmos.proto

package types

import (
	fmt "fmt"
	_ "github.com/cosmos/cosmos-proto"
	github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
	types "github.com/cosmos/cosmos-sdk/types"
	_ "github.com/cosmos/gogoproto/gogoproto"
	proto "github.com/cosmos/gogoproto/proto"
	github_com_cosmos_gogoproto_types "github.com/cosmos/gogoproto/types"
	_ "google.golang.org/protobuf/types/known/timestamppb"
	io "io"
	math "math"
	math_bits "math/bits"
	time "time"
)

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

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// 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 AllowListedValidators struct {
	AllowListedValidators []AllowListedValidator `protobuf:"bytes,1,rep,name=allow_listed_validators,json=allowListedValidators,proto3" json:"allow_listed_validators" yaml:"allow_lised_validators"`
}

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

var xxx_messageInfo_AllowListedValidators proto.InternalMessageInfo

type AllowListedValidator struct {
	// validator_address defines the bech32-encoded address the allowlisted
	// validator
	ValidatorAddress string `protobuf:"bytes,1,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty" yaml:"validator_address"`
	// target_weight specifies the target weight for liquid staking, unstaking
	// amount, which is a value for calculating the real weight to be derived
	// according to the active status
	TargetWeight github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,2,opt,name=target_weight,json=targetWeight,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"target_weight" yaml:"target_weight"`
}

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

var xxx_messageInfo_AllowListedValidator proto.InternalMessageInfo

type PstakeParams struct {
	PstakeDepositFee    github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,1,opt,name=pstake_deposit_fee,json=pstakeDepositFee,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"pstake_deposit_fee"`
	PstakeRestakeFee    github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,2,opt,name=pstake_restake_fee,json=pstakeRestakeFee,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"pstake_restake_fee"`
	PstakeUnstakeFee    github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,3,opt,name=pstake_unstake_fee,json=pstakeUnstakeFee,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"pstake_unstake_fee"`
	PstakeRedemptionFee github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,4,opt,name=pstake_redemption_fee,json=pstakeRedemptionFee,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"pstake_redemption_fee"`
	PstakeFeeAddress    string                                 `protobuf:"bytes,5,opt,name=pstake_fee_address,json=pstakeFeeAddress,proto3" json:"pstake_fee_address,omitempty"`
}

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

var xxx_messageInfo_PstakeParams proto.InternalMessageInfo

// HostChainParams go into the DB
type HostChainParams struct {
	ChainID         string                                 `protobuf:"bytes,1,opt,name=chain_i_d,json=chainID,proto3" json:"chain_i_d,omitempty"`
	ConnectionID    string                                 `protobuf:"bytes,2,opt,name=connection_i_d,json=connectionID,proto3" json:"connection_i_d,omitempty"`
	TransferChannel string                                 `protobuf:"bytes,3,opt,name=transfer_channel,json=transferChannel,proto3" json:"transfer_channel,omitempty"`
	TransferPort    string                                 `protobuf:"bytes,4,opt,name=transfer_port,json=transferPort,proto3" json:"transfer_port,omitempty"`
	BaseDenom       string                                 `protobuf:"bytes,5,opt,name=base_denom,json=baseDenom,proto3" json:"base_denom,omitempty"`
	MintDenom       string                                 `protobuf:"bytes,6,opt,name=mint_denom,json=mintDenom,proto3" json:"mint_denom,omitempty"`
	MinDeposit      github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,7,opt,name=min_deposit,json=minDeposit,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"min_deposit"`
	PstakeParams    PstakeParams                           `protobuf:"bytes,8,opt,name=pstake_params,json=pstakeParams,proto3" json:"pstake_params"`
}

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

var xxx_messageInfo_HostChainParams proto.InternalMessageInfo

// DelegationState stores module account balance, ica account balance,
// delegation state, undelegation state
type DelegationState struct {
	// This field is necessary as the address of not blocked for send coins,
	// we only should care about funds that have come via proper channels.
	HostDelegationAccountBalance github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,1,rep,name=host_delegation_account_balance,json=hostDelegationAccountBalance,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"host_delegation_account_balance"`
	HostChainDelegationAddress   string                                   `protobuf:"bytes,2,opt,name=host_chain_delegation_address,json=hostChainDelegationAddress,proto3" json:"host_chain_delegation_address,omitempty"`
	HostAccountDelegations       []HostAccountDelegation                  `protobuf:"bytes,3,rep,name=host_account_delegations,json=hostAccountDelegations,proto3" json:"host_account_delegations"`
	HostAccountUndelegations     []HostAccountUndelegation                `protobuf:"bytes,4,rep,name=host_account_undelegations,json=hostAccountUndelegations,proto3" json:"host_account_undelegations"`
}

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

var xxx_messageInfo_DelegationState proto.InternalMessageInfo

type HostAccountDelegation struct {
	ValidatorAddress string     `protobuf:"bytes,1,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty"`
	Amount           types.Coin `protobuf:"bytes,2,opt,name=amount,proto3" json:"amount"`
}

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

var xxx_messageInfo_HostAccountDelegation proto.InternalMessageInfo

type HostAccountUndelegation struct {
	EpochNumber             int64               `protobuf:"varint,1,opt,name=epoch_number,json=epochNumber,proto3" json:"epoch_number,omitempty"`
	TotalUndelegationAmount types.Coin          `protobuf:"bytes,2,opt,name=total_undelegation_amount,json=totalUndelegationAmount,proto3" json:"total_undelegation_amount"`
	CompletionTime          time.Time           `protobuf:"bytes,3,opt,name=completion_time,json=completionTime,proto3,stdtime" json:"completion_time"`
	UndelegationEntries     []UndelegationEntry `protobuf:"bytes,4,rep,name=undelegation_entries,json=undelegationEntries,proto3" json:"undelegation_entries"`
}

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

var xxx_messageInfo_HostAccountUndelegation proto.InternalMessageInfo

type UndelegationEntry struct {
	ValidatorAddress string     `protobuf:"bytes,1,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty"`
	Amount           types.Coin `protobuf:"bytes,2,opt,name=amount,proto3" json:"amount"`
}

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

var xxx_messageInfo_UndelegationEntry proto.InternalMessageInfo

type HostChainRewardAddress struct {
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
}

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

var xxx_messageInfo_HostChainRewardAddress proto.InternalMessageInfo

type IBCAmountTransientStore struct {
	// ibc_transfer stores only tokens which have ibc denoms "ibc/HEXHASH"
	IBCTransfer github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,1,rep,name=i_b_c_transfer,json=iBCTransfer,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"i_b_c_transfer"`
	// ica_delegate stores only token which has staking baseDenom
	ICADelegate                    types.Coin                      `protobuf:"bytes,2,opt,name=i_c_a_delegate,json=iCADelegate,proto3" json:"i_c_a_delegate"`
	UndelegatonCompleteIBCTransfer []TransientUndelegationTransfer `protobuf:"bytes,3,rep,name=undelegaton_complete_i_b_c_transfer,json=undelegatonCompleteIBCTransfer,proto3" json:"undelegaton_complete_i_b_c_transfer"`
}

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

var xxx_messageInfo_IBCAmountTransientStore proto.InternalMessageInfo

type TransientUndelegationTransfer struct {
	EpochNumber    int64      `protobuf:"varint,1,opt,name=epoch_number,json=epochNumber,proto3" json:"epoch_number,omitempty"`
	AmountUnbonded types.Coin `protobuf:"bytes,2,opt,name=amount_unbonded,json=amountUnbonded,proto3" json:"amount_unbonded"`
}

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

var xxx_messageInfo_TransientUndelegationTransfer proto.InternalMessageInfo

type UnbondingEpochCValue struct {
	EpochNumber int64 `protobuf:"varint,1,opt,name=epoch_number,json=epochNumber,proto3" json:"epoch_number,omitempty"`
	// c_value = stk_burn.Amount/amount_unbonded.Amount
	STKBurn        types.Coin `protobuf:"bytes,2,opt,name=s_t_k_burn,json=sTKBurn,proto3" json:"s_t_k_burn"`
	AmountUnbonded types.Coin `protobuf:"bytes,3,opt,name=amount_unbonded,json=amountUnbonded,proto3" json:"amount_unbonded"`
	IsMatured      bool       `protobuf:"varint,4,opt,name=is_matured,json=isMatured,proto3" json:"is_matured,omitempty"`
	IsFailed       bool       `protobuf:"varint,5,opt,name=is_failed,json=isFailed,proto3" json:"is_failed,omitempty"`
}

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

var xxx_messageInfo_UnbondingEpochCValue proto.InternalMessageInfo

type DelegatorUnbondingEpochEntry struct {
	DelegatorAddress string     `protobuf:"bytes,1,opt,name=delegator_address,json=delegatorAddress,proto3" json:"delegator_address,omitempty"`
	EpochNumber      int64      `protobuf:"varint,2,opt,name=epoch_number,json=epochNumber,proto3" json:"epoch_number,omitempty"`
	Amount           types.Coin `protobuf:"bytes,3,opt,name=amount,proto3" json:"amount"`
}

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

var xxx_messageInfo_DelegatorUnbondingEpochEntry proto.InternalMessageInfo

type HostAccounts struct {
	DelegatorAccountOwnerID string `protobuf:"bytes,1,opt,name=delegator_account_owner_i_d,json=delegatorAccountOwnerID,proto3" json:"delegator_account_owner_i_d,omitempty"`
	RewardsAccountOwnerID   string `protobuf:"bytes,2,opt,name=rewards_account_owner_i_d,json=rewardsAccountOwnerID,proto3" json:"rewards_account_owner_i_d,omitempty"`
}

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

var xxx_messageInfo_HostAccounts proto.InternalMessageInfo

func init() {
	proto.RegisterType((*AllowListedValidators)(nil), "pstake.lscosmos.v1beta1.AllowListedValidators")
	proto.RegisterType((*AllowListedValidator)(nil), "pstake.lscosmos.v1beta1.AllowListedValidator")
	proto.RegisterType((*PstakeParams)(nil), "pstake.lscosmos.v1beta1.PstakeParams")
	proto.RegisterType((*HostChainParams)(nil), "pstake.lscosmos.v1beta1.HostChainParams")
	proto.RegisterType((*DelegationState)(nil), "pstake.lscosmos.v1beta1.DelegationState")
	proto.RegisterType((*HostAccountDelegation)(nil), "pstake.lscosmos.v1beta1.HostAccountDelegation")
	proto.RegisterType((*HostAccountUndelegation)(nil), "pstake.lscosmos.v1beta1.HostAccountUndelegation")
	proto.RegisterType((*UndelegationEntry)(nil), "pstake.lscosmos.v1beta1.UndelegationEntry")
	proto.RegisterType((*HostChainRewardAddress)(nil), "pstake.lscosmos.v1beta1.HostChainRewardAddress")
	proto.RegisterType((*IBCAmountTransientStore)(nil), "pstake.lscosmos.v1beta1.IBCAmountTransientStore")
	proto.RegisterType((*TransientUndelegationTransfer)(nil), "pstake.lscosmos.v1beta1.TransientUndelegationTransfer")
	proto.RegisterType((*UnbondingEpochCValue)(nil), "pstake.lscosmos.v1beta1.UnbondingEpochCValue")
	proto.RegisterType((*DelegatorUnbondingEpochEntry)(nil), "pstake.lscosmos.v1beta1.DelegatorUnbondingEpochEntry")
	proto.RegisterType((*HostAccounts)(nil), "pstake.lscosmos.v1beta1.HostAccounts")
}

func init() {
	proto.RegisterFile("pstake/lscosmos/v1beta1/lscosmos.proto", fileDescriptor_4dec47e30da12f63)
}

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

func (this *AllowListedValidators) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*AllowListedValidators)
	if !ok {
		that2, ok := that.(AllowListedValidators)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.AllowListedValidators) != len(that1.AllowListedValidators) {
		return false
	}
	for i := range this.AllowListedValidators {
		if !this.AllowListedValidators[i].Equal(&that1.AllowListedValidators[i]) {
			return false
		}
	}
	return true
}
func (this *AllowListedValidator) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*AllowListedValidator)
	if !ok {
		that2, ok := that.(AllowListedValidator)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ValidatorAddress != that1.ValidatorAddress {
		return false
	}
	if !this.TargetWeight.Equal(that1.TargetWeight) {
		return false
	}
	return true
}
func (this *PstakeParams) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*PstakeParams)
	if !ok {
		that2, ok := that.(PstakeParams)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.PstakeDepositFee.Equal(that1.PstakeDepositFee) {
		return false
	}
	if !this.PstakeRestakeFee.Equal(that1.PstakeRestakeFee) {
		return false
	}
	if !this.PstakeUnstakeFee.Equal(that1.PstakeUnstakeFee) {
		return false
	}
	if !this.PstakeRedemptionFee.Equal(that1.PstakeRedemptionFee) {
		return false
	}
	if this.PstakeFeeAddress != that1.PstakeFeeAddress {
		return false
	}
	return true
}
func (this *HostChainParams) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*HostChainParams)
	if !ok {
		that2, ok := that.(HostChainParams)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ChainID != that1.ChainID {
		return false
	}
	if this.ConnectionID != that1.ConnectionID {
		return false
	}
	if this.TransferChannel != that1.TransferChannel {
		return false
	}
	if this.TransferPort != that1.TransferPort {
		return false
	}
	if this.BaseDenom != that1.BaseDenom {
		return false
	}
	if this.MintDenom != that1.MintDenom {
		return false
	}
	if !this.MinDeposit.Equal(that1.MinDeposit) {
		return false
	}
	if !this.PstakeParams.Equal(&that1.PstakeParams) {
		return false
	}
	return true
}
func (this *DelegationState) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DelegationState)
	if !ok {
		that2, ok := that.(DelegationState)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.HostDelegationAccountBalance) != len(that1.HostDelegationAccountBalance) {
		return false
	}
	for i := range this.HostDelegationAccountBalance {
		if !this.HostDelegationAccountBalance[i].Equal(&that1.HostDelegationAccountBalance[i]) {
			return false
		}
	}
	if this.HostChainDelegationAddress != that1.HostChainDelegationAddress {
		return false
	}
	if len(this.HostAccountDelegations) != len(that1.HostAccountDelegations) {
		return false
	}
	for i := range this.HostAccountDelegations {
		if !this.HostAccountDelegations[i].Equal(&that1.HostAccountDelegations[i]) {
			return false
		}
	}
	if len(this.HostAccountUndelegations) != len(that1.HostAccountUndelegations) {
		return false
	}
	for i := range this.HostAccountUndelegations {
		if !this.HostAccountUndelegations[i].Equal(&that1.HostAccountUndelegations[i]) {
			return false
		}
	}
	return true
}
func (this *HostAccountDelegation) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*HostAccountDelegation)
	if !ok {
		that2, ok := that.(HostAccountDelegation)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ValidatorAddress != that1.ValidatorAddress {
		return false
	}
	if !this.Amount.Equal(&that1.Amount) {
		return false
	}
	return true
}
func (this *HostAccountUndelegation) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*HostAccountUndelegation)
	if !ok {
		that2, ok := that.(HostAccountUndelegation)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.EpochNumber != that1.EpochNumber {
		return false
	}
	if !this.TotalUndelegationAmount.Equal(&that1.TotalUndelegationAmount) {
		return false
	}
	if !this.CompletionTime.Equal(that1.CompletionTime) {
		return false
	}
	if len(this.UndelegationEntries) != len(that1.UndelegationEntries) {
		return false
	}
	for i := range this.UndelegationEntries {
		if !this.UndelegationEntries[i].Equal(&that1.UndelegationEntries[i]) {
			return false
		}
	}
	return true
}
func (this *UndelegationEntry) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*UndelegationEntry)
	if !ok {
		that2, ok := that.(UndelegationEntry)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ValidatorAddress != that1.ValidatorAddress {
		return false
	}
	if !this.Amount.Equal(&that1.Amount) {
		return false
	}
	return true
}
func (this *HostChainRewardAddress) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*HostChainRewardAddress)
	if !ok {
		that2, ok := that.(HostChainRewardAddress)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Address != that1.Address {
		return false
	}
	return true
}
func (this *IBCAmountTransientStore) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*IBCAmountTransientStore)
	if !ok {
		that2, ok := that.(IBCAmountTransientStore)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.IBCTransfer) != len(that1.IBCTransfer) {
		return false
	}
	for i := range this.IBCTransfer {
		if !this.IBCTransfer[i].Equal(&that1.IBCTransfer[i]) {
			return false
		}
	}
	if !this.ICADelegate.Equal(&that1.ICADelegate) {
		return false
	}
	if len(this.UndelegatonCompleteIBCTransfer) != len(that1.UndelegatonCompleteIBCTransfer) {
		return false
	}
	for i := range this.UndelegatonCompleteIBCTransfer {
		if !this.UndelegatonCompleteIBCTransfer[i].Equal(&that1.UndelegatonCompleteIBCTransfer[i]) {
			return false
		}
	}
	return true
}
func (this *TransientUndelegationTransfer) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*TransientUndelegationTransfer)
	if !ok {
		that2, ok := that.(TransientUndelegationTransfer)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.EpochNumber != that1.EpochNumber {
		return false
	}
	if !this.AmountUnbonded.Equal(&that1.AmountUnbonded) {
		return false
	}
	return true
}
func (this *UnbondingEpochCValue) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*UnbondingEpochCValue)
	if !ok {
		that2, ok := that.(UnbondingEpochCValue)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.EpochNumber != that1.EpochNumber {
		return false
	}
	if !this.STKBurn.Equal(&that1.STKBurn) {
		return false
	}
	if !this.AmountUnbonded.Equal(&that1.AmountUnbonded) {
		return false
	}
	if this.IsMatured != that1.IsMatured {
		return false
	}
	if this.IsFailed != that1.IsFailed {
		return false
	}
	return true
}
func (this *DelegatorUnbondingEpochEntry) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DelegatorUnbondingEpochEntry)
	if !ok {
		that2, ok := that.(DelegatorUnbondingEpochEntry)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.DelegatorAddress != that1.DelegatorAddress {
		return false
	}
	if this.EpochNumber != that1.EpochNumber {
		return false
	}
	if !this.Amount.Equal(&that1.Amount) {
		return false
	}
	return true
}
func (this *HostAccounts) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*HostAccounts)
	if !ok {
		that2, ok := that.(HostAccounts)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.DelegatorAccountOwnerID != that1.DelegatorAccountOwnerID {
		return false
	}
	if this.RewardsAccountOwnerID != that1.RewardsAccountOwnerID {
		return false
	}
	return true
}
func (m *AllowListedValidators) 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 *AllowListedValidators) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *AllowListedValidator) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.TargetWeight.Size()
		i -= size
		if _, err := m.TargetWeight.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintLscosmos(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.ValidatorAddress) > 0 {
		i -= len(m.ValidatorAddress)
		copy(dAtA[i:], m.ValidatorAddress)
		i = encodeVarintLscosmos(dAtA, i, uint64(len(m.ValidatorAddress)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *PstakeParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.PstakeFeeAddress) > 0 {
		i -= len(m.PstakeFeeAddress)
		copy(dAtA[i:], m.PstakeFeeAddress)
		i = encodeVarintLscosmos(dAtA, i, uint64(len(m.PstakeFeeAddress)))
		i--
		dAtA[i] = 0x2a
	}
	{
		size := m.PstakeRedemptionFee.Size()
		i -= size
		if _, err := m.PstakeRedemptionFee.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintLscosmos(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	{
		size := m.PstakeUnstakeFee.Size()
		i -= size
		if _, err := m.PstakeUnstakeFee.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintLscosmos(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size := m.PstakeRestakeFee.Size()
		i -= size
		if _, err := m.PstakeRestakeFee.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintLscosmos(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size := m.PstakeDepositFee.Size()
		i -= size
		if _, err := m.PstakeDepositFee.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintLscosmos(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *HostChainParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.PstakeParams.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintLscosmos(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x42
	{
		size := m.MinDeposit.Size()
		i -= size
		if _, err := m.MinDeposit.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintLscosmos(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x3a
	if len(m.MintDenom) > 0 {
		i -= len(m.MintDenom)
		copy(dAtA[i:], m.MintDenom)
		i = encodeVarintLscosmos(dAtA, i, uint64(len(m.MintDenom)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.BaseDenom) > 0 {
		i -= len(m.BaseDenom)
		copy(dAtA[i:], m.BaseDenom)
		i = encodeVarintLscosmos(dAtA, i, uint64(len(m.BaseDenom)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.TransferPort) > 0 {
		i -= len(m.TransferPort)
		copy(dAtA[i:], m.TransferPort)
		i = encodeVarintLscosmos(dAtA, i, uint64(len(m.TransferPort)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.TransferChannel) > 0 {
		i -= len(m.TransferChannel)
		copy(dAtA[i:], m.TransferChannel)
		i = encodeVarintLscosmos(dAtA, i, uint64(len(m.TransferChannel)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.ConnectionID) > 0 {
		i -= len(m.ConnectionID)
		copy(dAtA[i:], m.ConnectionID)
		i = encodeVarintLscosmos(dAtA, i, uint64(len(m.ConnectionID)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ChainID) > 0 {
		i -= len(m.ChainID)
		copy(dAtA[i:], m.ChainID)
		i = encodeVarintLscosmos(dAtA, i, uint64(len(m.ChainID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *DelegationState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.HostAccountUndelegations) > 0 {
		for iNdEx := len(m.HostAccountUndelegations) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.HostAccountUndelegations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintLscosmos(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.HostAccountDelegations) > 0 {
		for iNdEx := len(m.HostAccountDelegations) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.HostAccountDelegations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintLscosmos(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.HostChainDelegationAddress) > 0 {
		i -= len(m.HostChainDelegationAddress)
		copy(dAtA[i:], m.HostChainDelegationAddress)
		i = encodeVarintLscosmos(dAtA, i, uint64(len(m.HostChainDelegationAddress)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.HostDelegationAccountBalance) > 0 {
		for iNdEx := len(m.HostDelegationAccountBalance) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.HostDelegationAccountBalance[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintLscosmos(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *HostAccountUndelegation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.UndelegationEntries) > 0 {
		for iNdEx := len(m.UndelegationEntries) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.UndelegationEntries[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintLscosmos(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	n3, err3 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.CompletionTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.CompletionTime):])
	if err3 != nil {
		return 0, err3
	}
	i -= n3
	i = encodeVarintLscosmos(dAtA, i, uint64(n3))
	i--
	dAtA[i] = 0x1a
	{
		size, err := m.TotalUndelegationAmount.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintLscosmos(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.EpochNumber != 0 {
		i = encodeVarintLscosmos(dAtA, i, uint64(m.EpochNumber))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *IBCAmountTransientStore) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.UndelegatonCompleteIBCTransfer) > 0 {
		for iNdEx := len(m.UndelegatonCompleteIBCTransfer) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.UndelegatonCompleteIBCTransfer[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintLscosmos(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	{
		size, err := m.ICADelegate.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintLscosmos(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.IBCTransfer) > 0 {
		for iNdEx := len(m.IBCTransfer) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.IBCTransfer[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintLscosmos(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *TransientUndelegationTransfer) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.AmountUnbonded.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintLscosmos(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.EpochNumber != 0 {
		i = encodeVarintLscosmos(dAtA, i, uint64(m.EpochNumber))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *UnbondingEpochCValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IsFailed {
		i--
		if m.IsFailed {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if m.IsMatured {
		i--
		if m.IsMatured {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	{
		size, err := m.AmountUnbonded.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintLscosmos(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size, err := m.STKBurn.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintLscosmos(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.EpochNumber != 0 {
		i = encodeVarintLscosmos(dAtA, i, uint64(m.EpochNumber))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *DelegatorUnbondingEpochEntry) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Amount.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintLscosmos(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if m.EpochNumber != 0 {
		i = encodeVarintLscosmos(dAtA, i, uint64(m.EpochNumber))
		i--
		dAtA[i] = 0x10
	}
	if len(m.DelegatorAddress) > 0 {
		i -= len(m.DelegatorAddress)
		copy(dAtA[i:], m.DelegatorAddress)
		i = encodeVarintLscosmos(dAtA, i, uint64(len(m.DelegatorAddress)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *AllowListedValidator) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ValidatorAddress)
	if l > 0 {
		n += 1 + l + sovLscosmos(uint64(l))
	}
	l = m.TargetWeight.Size()
	n += 1 + l + sovLscosmos(uint64(l))
	return n
}

func (m *PstakeParams) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.PstakeDepositFee.Size()
	n += 1 + l + sovLscosmos(uint64(l))
	l = m.PstakeRestakeFee.Size()
	n += 1 + l + sovLscosmos(uint64(l))
	l = m.PstakeUnstakeFee.Size()
	n += 1 + l + sovLscosmos(uint64(l))
	l = m.PstakeRedemptionFee.Size()
	n += 1 + l + sovLscosmos(uint64(l))
	l = len(m.PstakeFeeAddress)
	if l > 0 {
		n += 1 + l + sovLscosmos(uint64(l))
	}
	return n
}

func (m *HostChainParams) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ChainID)
	if l > 0 {
		n += 1 + l + sovLscosmos(uint64(l))
	}
	l = len(m.ConnectionID)
	if l > 0 {
		n += 1 + l + sovLscosmos(uint64(l))
	}
	l = len(m.TransferChannel)
	if l > 0 {
		n += 1 + l + sovLscosmos(uint64(l))
	}
	l = len(m.TransferPort)
	if l > 0 {
		n += 1 + l + sovLscosmos(uint64(l))
	}
	l = len(m.BaseDenom)
	if l > 0 {
		n += 1 + l + sovLscosmos(uint64(l))
	}
	l = len(m.MintDenom)
	if l > 0 {
		n += 1 + l + sovLscosmos(uint64(l))
	}
	l = m.MinDeposit.Size()
	n += 1 + l + sovLscosmos(uint64(l))
	l = m.PstakeParams.Size()
	n += 1 + l + sovLscosmos(uint64(l))
	return n
}

func (m *DelegationState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.HostDelegationAccountBalance) > 0 {
		for _, e := range m.HostDelegationAccountBalance {
			l = e.Size()
			n += 1 + l + sovLscosmos(uint64(l))
		}
	}
	l = len(m.HostChainDelegationAddress)
	if l > 0 {
		n += 1 + l + sovLscosmos(uint64(l))
	}
	if len(m.HostAccountDelegations) > 0 {
		for _, e := range m.HostAccountDelegations {
			l = e.Size()
			n += 1 + l + sovLscosmos(uint64(l))
		}
	}
	if len(m.HostAccountUndelegations) > 0 {
		for _, e := range m.HostAccountUndelegations {
			l = e.Size()
			n += 1 + l + sovLscosmos(uint64(l))
		}
	}
	return n
}

func (m *HostAccountDelegation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ValidatorAddress)
	if l > 0 {
		n += 1 + l + sovLscosmos(uint64(l))
	}
	l = m.Amount.Size()
	n += 1 + l + sovLscosmos(uint64(l))
	return n
}

func (m *HostAccountUndelegation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.EpochNumber != 0 {
		n += 1 + sovLscosmos(uint64(m.EpochNumber))
	}
	l = m.TotalUndelegationAmount.Size()
	n += 1 + l + sovLscosmos(uint64(l))
	l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.CompletionTime)
	n += 1 + l + sovLscosmos(uint64(l))
	if len(m.UndelegationEntries) > 0 {
		for _, e := range m.UndelegationEntries {
			l = e.Size()
			n += 1 + l + sovLscosmos(uint64(l))
		}
	}
	return n
}

func (m *UndelegationEntry) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ValidatorAddress)
	if l > 0 {
		n += 1 + l + sovLscosmos(uint64(l))
	}
	l = m.Amount.Size()
	n += 1 + l + sovLscosmos(uint64(l))
	return n
}

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

func (m *IBCAmountTransientStore) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.IBCTransfer) > 0 {
		for _, e := range m.IBCTransfer {
			l = e.Size()
			n += 1 + l + sovLscosmos(uint64(l))
		}
	}
	l = m.ICADelegate.Size()
	n += 1 + l + sovLscosmos(uint64(l))
	if len(m.UndelegatonCompleteIBCTransfer) > 0 {
		for _, e := range m.UndelegatonCompleteIBCTransfer {
			l = e.Size()
			n += 1 + l + sovLscosmos(uint64(l))
		}
	}
	return n
}

func (m *TransientUndelegationTransfer) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.EpochNumber != 0 {
		n += 1 + sovLscosmos(uint64(m.EpochNumber))
	}
	l = m.AmountUnbonded.Size()
	n += 1 + l + sovLscosmos(uint64(l))
	return n
}

func (m *UnbondingEpochCValue) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.EpochNumber != 0 {
		n += 1 + sovLscosmos(uint64(m.EpochNumber))
	}
	l = m.STKBurn.Size()
	n += 1 + l + sovLscosmos(uint64(l))
	l = m.AmountUnbonded.Size()
	n += 1 + l + sovLscosmos(uint64(l))
	if m.IsMatured {
		n += 2
	}
	if m.IsFailed {
		n += 2
	}
	return n
}

func (m *DelegatorUnbondingEpochEntry) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.DelegatorAddress)
	if l > 0 {
		n += 1 + l + sovLscosmos(uint64(l))
	}
	if m.EpochNumber != 0 {
		n += 1 + sovLscosmos(uint64(m.EpochNumber))
	}
	l = m.Amount.Size()
	n += 1 + l + sovLscosmos(uint64(l))
	return n
}

func (m *HostAccounts) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.DelegatorAccountOwnerID)
	if l > 0 {
		n += 1 + l + sovLscosmos(uint64(l))
	}
	l = len(m.RewardsAccountOwnerID)
	if l > 0 {
		n += 1 + l + sovLscosmos(uint64(l))
	}
	return n
}

func sovLscosmos(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozLscosmos(x uint64) (n int) {
	return sovLscosmos(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *AllowListedValidators) 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 ErrIntOverflowLscosmos
			}
			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: AllowListedValidators: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AllowListedValidators: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AllowListedValidators", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLscosmos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLscosmos
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLscosmos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AllowListedValidators = append(m.AllowListedValidators, AllowListedValidator{})
			if err := m.AllowListedValidators[len(m.AllowListedValidators)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLscosmos(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLscosmos
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AllowListedValidator) 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 ErrIntOverflowLscosmos
			}
			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: AllowListedValidator: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AllowListedValidator: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLscosmos
				}
				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 ErrInvalidLengthLscosmos
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLscosmos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ValidatorAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TargetWeight", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLscosmos
				}
				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 ErrInvalidLengthLscosmos
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLscosmos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.TargetWeight.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLscosmos(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLscosmos
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PstakeParams) 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 ErrIntOverflowLscosmos
			}
			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: PstakeParams: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PstakeParams: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PstakeDepositFee", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLscosmos
				}
				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 ErrInvalidLengthLscosmos
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLscosmos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.PstakeDepositFee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PstakeRestakeFee", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLscosmos
				}
				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 ErrInvalidLengthLscosmos
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLscosmos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.PstakeRestakeFee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PstakeUnstakeFee", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLscosmos
				}
				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 ErrInvalidLengthLscosmos
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLscosmos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.PstakeUnstakeFee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PstakeRedemptionFee", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLscosmos
				}
				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 ErrInvalidLengthLscosmos
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLscosmos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.PstakeRedemptionFee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PstakeFeeAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLscosmos
				}
				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 ErrInvalidLengthLscosmos
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLscosmos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PstakeFeeAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLscosmos(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLscosmos
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HostChainParams) 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 ErrIntOverflowLscosmos
			}
			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: HostChainParams: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HostChainParams: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowLscosmos
				}
				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 ErrInvalidLengthLscosmos
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLscosmos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ChainID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		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 ErrIntOverflowLscosmos
				}
				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 ErrInvalidLengthLscosmos
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLscosmos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ConnectionID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TransferChannel", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLscosmos
				}
				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 ErrInvalidLengthLscosmos
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLscosmos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TransferChannel = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TransferPort", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLscosmos
				}
				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 ErrInvalidLengthLscosmos
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLscosmos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TransferPort = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BaseDenom", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLscosmos
				}
				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 ErrInvalidLengthLscosmos
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLscosmos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BaseDenom = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MintDenom", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLscosmos
				}
				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 ErrInvalidLengthLscosmos
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLscosmos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MintDenom = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinDeposit", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLscosmos
				}
				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 ErrInvalidLengthLscosmos
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLscosmos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MinDeposit.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PstakeParams", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLscosmos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLscosmos
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLscosmos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.PstakeParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLscosmos(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLscosmos
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DelegationState) 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 ErrIntOverflowLscosmos
			}
			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: DelegationState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DelegationState: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HostDelegationAccountBalance", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLscosmos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLscosmos
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLscosmos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.HostDelegationAccountBalance = append(m.HostDelegationAccountBalance, types.Coin{})
			if err := m.HostDelegationAccountBalance[len(m.HostDelegationAccountBalance)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HostChainDelegationAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLscosmos
				}
				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 ErrInvalidLengthLscosmos
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLscosmos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.HostChainDelegationAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HostAccountDelegations", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLscosmos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLscosmos
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLscosmos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.HostAccountDelegations = append(m.HostAccountDelegations, HostAccountDelegation{})
			if err := m.HostAccountDelegations[len(m.HostAccountDelegations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HostAccountUndelegations", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLscosmos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLscosmos
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLscosmos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.HostAccountUndelegations = append(m.HostAccountUndelegations, HostAccountUndelegation{})
			if err := m.HostAccountUndelegations[len(m.HostAccountUndelegations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLscosmos(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLscosmos
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HostAccountUndelegation) 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 ErrIntOverflowLscosmos
			}
			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: HostAccountUndelegation: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HostAccountUndelegation: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EpochNumber", wireType)
			}
			m.EpochNumber = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLscosmos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EpochNumber |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalUndelegationAmount", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLscosmos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLscosmos
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLscosmos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.TotalUndelegationAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CompletionTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLscosmos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLscosmos
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLscosmos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.CompletionTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UndelegationEntries", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLscosmos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLscosmos
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLscosmos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UndelegationEntries = append(m.UndelegationEntries, UndelegationEntry{})
			if err := m.UndelegationEntries[len(m.UndelegationEntries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLscosmos(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLscosmos
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HostChainRewardAddress) 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 ErrIntOverflowLscosmos
			}
			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: HostChainRewardAddress: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HostChainRewardAddress: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLscosmos
				}
				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 ErrInvalidLengthLscosmos
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLscosmos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLscosmos(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLscosmos
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *IBCAmountTransientStore) 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 ErrIntOverflowLscosmos
			}
			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: IBCAmountTransientStore: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IBCAmountTransientStore: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IBCTransfer", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLscosmos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLscosmos
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLscosmos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IBCTransfer = append(m.IBCTransfer, types.Coin{})
			if err := m.IBCTransfer[len(m.IBCTransfer)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ICADelegate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLscosmos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLscosmos
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLscosmos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ICADelegate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UndelegatonCompleteIBCTransfer", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLscosmos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLscosmos
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLscosmos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UndelegatonCompleteIBCTransfer = append(m.UndelegatonCompleteIBCTransfer, TransientUndelegationTransfer{})
			if err := m.UndelegatonCompleteIBCTransfer[len(m.UndelegatonCompleteIBCTransfer)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLscosmos(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLscosmos
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UnbondingEpochCValue) 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 ErrIntOverflowLscosmos
			}
			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: UnbondingEpochCValue: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UnbondingEpochCValue: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EpochNumber", wireType)
			}
			m.EpochNumber = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLscosmos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EpochNumber |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field STKBurn", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLscosmos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLscosmos
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLscosmos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.STKBurn.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AmountUnbonded", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLscosmos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLscosmos
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLscosmos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.AmountUnbonded.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsMatured", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLscosmos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsMatured = bool(v != 0)
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsFailed", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLscosmos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsFailed = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipLscosmos(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLscosmos
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HostAccounts) 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 ErrIntOverflowLscosmos
			}
			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: HostAccounts: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HostAccounts: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DelegatorAccountOwnerID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLscosmos
				}
				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 ErrInvalidLengthLscosmos
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLscosmos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DelegatorAccountOwnerID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RewardsAccountOwnerID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLscosmos
				}
				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 ErrInvalidLengthLscosmos
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLscosmos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RewardsAccountOwnerID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLscosmos(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLscosmos
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipLscosmos(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, ErrIntOverflowLscosmos
			}
			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, ErrIntOverflowLscosmos
				}
				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, ErrIntOverflowLscosmos
				}
				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, ErrInvalidLengthLscosmos
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupLscosmos
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthLscosmos
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthLscosmos        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowLscosmos          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupLscosmos = fmt.Errorf("proto: unexpected end of group")
)