liquidstaking.pb.go

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

package types

import (
	fmt "fmt"
	_ "github.com/cosmos/cosmos-sdk/types"
	github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	_ "github.com/grpc-ecosystem/grpc-gateway/v2/protoc-gen-openapiv2/options"
	_ "github.com/regen-network/cosmos-proto"
	_ "google.golang.org/protobuf/types/known/timestamppb"
	io "io"
	math "math"
	math_bits "math/bits"
)

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

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

// ValidatorStatus enumerates the status of a liquid validator.
type ValidatorStatus int32

const (
	// VALIDATOR_STATUS_UNSPECIFIED defines the unspecified invalid status.
	ValidatorStatusUnspecified ValidatorStatus = 0
	// VALIDATOR_STATUS_ACTIVE defines the active, valid status
	ValidatorStatusActive ValidatorStatus = 1
	// VALIDATOR_STATUS_INACTIVE defines the inactive, invalid status
	ValidatorStatusInactive ValidatorStatus = 2
)

var ValidatorStatus_name = map[int32]string{
	0: "VALIDATOR_STATUS_UNSPECIFIED",
	1: "VALIDATOR_STATUS_ACTIVE",
	2: "VALIDATOR_STATUS_INACTIVE",
}

var ValidatorStatus_value = map[string]int32{
	"VALIDATOR_STATUS_UNSPECIFIED": 0,
	"VALIDATOR_STATUS_ACTIVE":      1,
	"VALIDATOR_STATUS_INACTIVE":    2,
}

func (x ValidatorStatus) String() string {
	return proto.EnumName(ValidatorStatus_name, int32(x))
}

func (ValidatorStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_f11ef7f6d0889fb0, []int{0}
}

// Params defines the set of params for the liquidstaking module.
type Params struct {
	// LiquidBondDenom specifies the denomination of the token receiving after LiquidStaking, The value is calculated
	// through NetAmount.
	LiquidBondDenom string `protobuf:"bytes,1,opt,name=liquid_bond_denom,json=liquidBondDenom,proto3" json:"liquid_bond_denom,omitempty" yaml:"liquid_bond_denom"`
	// WhitelistedValidators specifies the validators elected to become Active Liquid Validators.
	WhitelistedValidators []WhitelistedValidator `protobuf:"bytes,2,rep,name=whitelisted_validators,json=whitelistedValidators,proto3" json:"whitelisted_validators" yaml:"whitelisted_validators"`
	// UnstakeFeeRate specifies the fee rate when liquid unstake is requested, unbonded by subtracting it from
	// unbondingAmount
	UnstakeFeeRate github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,3,opt,name=unstake_fee_rate,json=unstakeFeeRate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"unstake_fee_rate" yaml:"unstake_fee_rate"`
	// MinLiquidStakingAmount specifies the minimum number of coins to be staked to the active liquid validators on liquid
	// staking to minimize decimal loss and consider gas efficiency.
	MinLiquidStakingAmount github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,5,opt,name=min_liquid_staking_amount,json=minLiquidStakingAmount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"min_liquid_staking_amount" yaml:"min_liquid_staking_amount"`
}

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

var xxx_messageInfo_Params proto.InternalMessageInfo

// WhitelistedValidator consists of the validator operator address and the target weight, which is a value for
// calculating the real weight to be derived according to the active status. In the case of inactive, it is calculated
// as zero.
type WhitelistedValidator struct {
	// validator_address defines the bech32-encoded address that whitelisted 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.Int `protobuf:"bytes,2,opt,name=target_weight,json=targetWeight,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"target_weight" yaml:"target_weight"`
}

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

var xxx_messageInfo_WhitelistedValidator proto.InternalMessageInfo

// LiquidValidator defines a Validator that can be the target of LiquidStaking and LiquidUnstaking, Active, Weight, etc.
// fields are derived as functions to deal with by maintaining consistency with the state of the staking module.
type LiquidValidator struct {
	// operator_address defines the address of the validator's operator; bech encoded in JSON.
	OperatorAddress string `protobuf:"bytes,1,opt,name=operator_address,json=operatorAddress,proto3" json:"operator_address,omitempty" yaml:"operator_address"`
}

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

var xxx_messageInfo_LiquidValidator proto.InternalMessageInfo

// LiquidValidatorState is type LiquidValidator with state added to return to query results.
type LiquidValidatorState struct {
	// operator_address defines the address of the validator's operator; bech encoded in JSON.
	OperatorAddress string `protobuf:"bytes,1,opt,name=operator_address,json=operatorAddress,proto3" json:"operator_address,omitempty" yaml:"operator_address"`
	// weight specifies the weight for liquid staking, unstaking amount
	Weight github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=weight,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"weight" yaml:"weight"`
	// status is the liquid validator status
	Status ValidatorStatus `protobuf:"varint,3,opt,name=status,proto3,enum=crescent.liquidstaking.v1beta1.ValidatorStatus" json:"status,omitempty"`
	// del_shares define the delegation shares of the validator
	DelShares github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,4,opt,name=del_shares,json=delShares,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"del_shares"`
	// liquid_tokens define the token amount worth of delegation shares of the validator (slashing applied amount)
	LiquidTokens github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,5,opt,name=liquid_tokens,json=liquidTokens,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"liquid_tokens"`
}

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

var xxx_messageInfo_LiquidValidatorState proto.InternalMessageInfo

// NetAmountState is type for net amount raw data and mint rate, This is a value that depends on the several module
// state every time, so it is used only for calculation and query and is not stored in kv.
type NetAmountState struct {
	// mint_rate is bTokenTotalSupply / NetAmount
	MintRate github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,1,opt,name=mint_rate,json=mintRate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"mint_rate"`
	// btoken_total_supply returns the total supply of btoken(liquid_bond_denom)
	BtokenTotalSupply github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=btoken_total_supply,json=btokenTotalSupply,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"btoken_total_supply"`
	// net_amount is proxy account's native token balance + total liquid tokens + total remaining rewards + total
	// unbonding balance
	NetAmount github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,3,opt,name=net_amount,json=netAmount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"net_amount"`
	// total_del_shares define the delegation shares of all liquid validators
	TotalDelShares github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,4,opt,name=total_del_shares,json=totalDelShares,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"total_del_shares"`
	// total_liquid_tokens define the token amount worth of delegation shares of all liquid validator (slashing applied
	// amount)
	TotalLiquidTokens github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,5,opt,name=total_liquid_tokens,json=totalLiquidTokens,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"total_liquid_tokens"`
	// total_remaining_rewards define the sum of remaining rewards of proxy account by all liquid validators
	TotalRemainingRewards github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,6,opt,name=total_remaining_rewards,json=totalRemainingRewards,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"total_remaining_rewards"`
	// total_unbonding_balance define the unbonding balance of proxy account by all liquid validator (slashing applied
	// amount)
	TotalUnbondingBalance github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,7,opt,name=total_unbonding_balance,json=totalUnbondingBalance,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"total_unbonding_balance"`
	// proxy_acc_balance define the balance of proxy account for the native token
	ProxyAccBalance github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,8,opt,name=proxy_acc_balance,json=proxyAccBalance,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"proxy_acc_balance"`
}

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

var xxx_messageInfo_NetAmountState proto.InternalMessageInfo

// VotingPower is type for current voting power of the voter including staking module's voting power and liquid staking
// module's voting power, It depends on the amount of delegation of staking module, the bonded state of the delegated
// validator, the value of btoken(liquid_bond_denom), and the pool coin and farming position containing btoken..
type VotingPower struct {
	// voter defines the address of the voter; bech encoded in JSON.
	Voter string `protobuf:"bytes,1,opt,name=voter,proto3" json:"voter,omitempty"`
	// staking_voting_power return the voting power of staking that can be exercised.
	StakingVotingPower github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=staking_voting_power,json=stakingVotingPower,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"staking_voting_power"`
	// liquid_staking_voting_power return the voting power of liquid staking that can be exercised.
	LiquidStakingVotingPower github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,3,opt,name=liquid_staking_voting_power,json=liquidStakingVotingPower,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"liquid_staking_voting_power"`
	// validator_voting_power return the voting power of the validator if the voter is the validator operator that can be
	// exercised.
	ValidatorVotingPower github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,4,opt,name=validator_voting_power,json=validatorVotingPower,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"validator_voting_power"`
}

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

var xxx_messageInfo_VotingPower proto.InternalMessageInfo

func init() {
	proto.RegisterEnum("crescent.liquidstaking.v1beta1.ValidatorStatus", ValidatorStatus_name, ValidatorStatus_value)
	proto.RegisterType((*Params)(nil), "crescent.liquidstaking.v1beta1.Params")
	proto.RegisterType((*WhitelistedValidator)(nil), "crescent.liquidstaking.v1beta1.WhitelistedValidator")
	proto.RegisterType((*LiquidValidator)(nil), "crescent.liquidstaking.v1beta1.LiquidValidator")
	proto.RegisterType((*LiquidValidatorState)(nil), "crescent.liquidstaking.v1beta1.LiquidValidatorState")
	proto.RegisterType((*NetAmountState)(nil), "crescent.liquidstaking.v1beta1.NetAmountState")
	proto.RegisterType((*VotingPower)(nil), "crescent.liquidstaking.v1beta1.VotingPower")
}

func init() {
	proto.RegisterFile("crescent/liquidstaking/v1beta1/liquidstaking.proto", fileDescriptor_f11ef7f6d0889fb0)
}

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

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

func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.MinLiquidStakingAmount.Size()
		i -= size
		if _, err := m.MinLiquidStakingAmount.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintLiquidstaking(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	{
		size := m.UnstakeFeeRate.Size()
		i -= size
		if _, err := m.UnstakeFeeRate.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintLiquidstaking(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if len(m.WhitelistedValidators) > 0 {
		for iNdEx := len(m.WhitelistedValidators) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.WhitelistedValidators[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintLiquidstaking(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.LiquidBondDenom) > 0 {
		i -= len(m.LiquidBondDenom)
		copy(dAtA[i:], m.LiquidBondDenom)
		i = encodeVarintLiquidstaking(dAtA, i, uint64(len(m.LiquidBondDenom)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *WhitelistedValidator) 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 = encodeVarintLiquidstaking(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.ValidatorAddress) > 0 {
		i -= len(m.ValidatorAddress)
		copy(dAtA[i:], m.ValidatorAddress)
		i = encodeVarintLiquidstaking(dAtA, i, uint64(len(m.ValidatorAddress)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *LiquidValidatorState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.LiquidTokens.Size()
		i -= size
		if _, err := m.LiquidTokens.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintLiquidstaking(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	{
		size := m.DelShares.Size()
		i -= size
		if _, err := m.DelShares.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintLiquidstaking(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if m.Status != 0 {
		i = encodeVarintLiquidstaking(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x18
	}
	{
		size := m.Weight.Size()
		i -= size
		if _, err := m.Weight.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintLiquidstaking(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.OperatorAddress) > 0 {
		i -= len(m.OperatorAddress)
		copy(dAtA[i:], m.OperatorAddress)
		i = encodeVarintLiquidstaking(dAtA, i, uint64(len(m.OperatorAddress)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *NetAmountState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.ProxyAccBalance.Size()
		i -= size
		if _, err := m.ProxyAccBalance.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintLiquidstaking(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x42
	{
		size := m.TotalUnbondingBalance.Size()
		i -= size
		if _, err := m.TotalUnbondingBalance.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintLiquidstaking(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x3a
	{
		size := m.TotalRemainingRewards.Size()
		i -= size
		if _, err := m.TotalRemainingRewards.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintLiquidstaking(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x32
	{
		size := m.TotalLiquidTokens.Size()
		i -= size
		if _, err := m.TotalLiquidTokens.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintLiquidstaking(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	{
		size := m.TotalDelShares.Size()
		i -= size
		if _, err := m.TotalDelShares.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintLiquidstaking(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	{
		size := m.NetAmount.Size()
		i -= size
		if _, err := m.NetAmount.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintLiquidstaking(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size := m.BtokenTotalSupply.Size()
		i -= size
		if _, err := m.BtokenTotalSupply.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintLiquidstaking(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size := m.MintRate.Size()
		i -= size
		if _, err := m.MintRate.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintLiquidstaking(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *VotingPower) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.ValidatorVotingPower.Size()
		i -= size
		if _, err := m.ValidatorVotingPower.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintLiquidstaking(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	{
		size := m.LiquidStakingVotingPower.Size()
		i -= size
		if _, err := m.LiquidStakingVotingPower.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintLiquidstaking(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size := m.StakingVotingPower.Size()
		i -= size
		if _, err := m.StakingVotingPower.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintLiquidstaking(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.Voter) > 0 {
		i -= len(m.Voter)
		copy(dAtA[i:], m.Voter)
		i = encodeVarintLiquidstaking(dAtA, i, uint64(len(m.Voter)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *LiquidValidatorState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.OperatorAddress)
	if l > 0 {
		n += 1 + l + sovLiquidstaking(uint64(l))
	}
	l = m.Weight.Size()
	n += 1 + l + sovLiquidstaking(uint64(l))
	if m.Status != 0 {
		n += 1 + sovLiquidstaking(uint64(m.Status))
	}
	l = m.DelShares.Size()
	n += 1 + l + sovLiquidstaking(uint64(l))
	l = m.LiquidTokens.Size()
	n += 1 + l + sovLiquidstaking(uint64(l))
	return n
}

func (m *NetAmountState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.MintRate.Size()
	n += 1 + l + sovLiquidstaking(uint64(l))
	l = m.BtokenTotalSupply.Size()
	n += 1 + l + sovLiquidstaking(uint64(l))
	l = m.NetAmount.Size()
	n += 1 + l + sovLiquidstaking(uint64(l))
	l = m.TotalDelShares.Size()
	n += 1 + l + sovLiquidstaking(uint64(l))
	l = m.TotalLiquidTokens.Size()
	n += 1 + l + sovLiquidstaking(uint64(l))
	l = m.TotalRemainingRewards.Size()
	n += 1 + l + sovLiquidstaking(uint64(l))
	l = m.TotalUnbondingBalance.Size()
	n += 1 + l + sovLiquidstaking(uint64(l))
	l = m.ProxyAccBalance.Size()
	n += 1 + l + sovLiquidstaking(uint64(l))
	return n
}

func (m *VotingPower) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Voter)
	if l > 0 {
		n += 1 + l + sovLiquidstaking(uint64(l))
	}
	l = m.StakingVotingPower.Size()
	n += 1 + l + sovLiquidstaking(uint64(l))
	l = m.LiquidStakingVotingPower.Size()
	n += 1 + l + sovLiquidstaking(uint64(l))
	l = m.ValidatorVotingPower.Size()
	n += 1 + l + sovLiquidstaking(uint64(l))
	return n
}

func sovLiquidstaking(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozLiquidstaking(x uint64) (n int) {
	return sovLiquidstaking(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Params) 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 ErrIntOverflowLiquidstaking
			}
			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: Params: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Params: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LiquidBondDenom", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidstaking
				}
				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 ErrInvalidLengthLiquidstaking
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLiquidstaking
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LiquidBondDenom = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WhitelistedValidators", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidstaking
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLiquidstaking
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLiquidstaking
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.WhitelistedValidators = append(m.WhitelistedValidators, WhitelistedValidator{})
			if err := m.WhitelistedValidators[len(m.WhitelistedValidators)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UnstakeFeeRate", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidstaking
				}
				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 ErrInvalidLengthLiquidstaking
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLiquidstaking
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.UnstakeFeeRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinLiquidStakingAmount", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidstaking
				}
				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 ErrInvalidLengthLiquidstaking
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLiquidstaking
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MinLiquidStakingAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLiquidstaking(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLiquidstaking
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *WhitelistedValidator) 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 ErrIntOverflowLiquidstaking
			}
			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: WhitelistedValidator: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WhitelistedValidator: 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 ErrIntOverflowLiquidstaking
				}
				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 ErrInvalidLengthLiquidstaking
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLiquidstaking
			}
			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 ErrIntOverflowLiquidstaking
				}
				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 ErrInvalidLengthLiquidstaking
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLiquidstaking
			}
			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 := skipLiquidstaking(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLiquidstaking
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LiquidValidatorState) 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 ErrIntOverflowLiquidstaking
			}
			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: LiquidValidatorState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LiquidValidatorState: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OperatorAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidstaking
				}
				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 ErrInvalidLengthLiquidstaking
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLiquidstaking
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OperatorAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Weight", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidstaking
				}
				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 ErrInvalidLengthLiquidstaking
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLiquidstaking
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Weight.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidstaking
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= ValidatorStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DelShares", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidstaking
				}
				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 ErrInvalidLengthLiquidstaking
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLiquidstaking
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.DelShares.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LiquidTokens", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidstaking
				}
				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 ErrInvalidLengthLiquidstaking
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLiquidstaking
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.LiquidTokens.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLiquidstaking(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLiquidstaking
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NetAmountState) 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 ErrIntOverflowLiquidstaking
			}
			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: NetAmountState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NetAmountState: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MintRate", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidstaking
				}
				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 ErrInvalidLengthLiquidstaking
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLiquidstaking
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MintRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BtokenTotalSupply", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidstaking
				}
				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 ErrInvalidLengthLiquidstaking
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLiquidstaking
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.BtokenTotalSupply.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NetAmount", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidstaking
				}
				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 ErrInvalidLengthLiquidstaking
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLiquidstaking
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.NetAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalDelShares", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidstaking
				}
				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 ErrInvalidLengthLiquidstaking
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLiquidstaking
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.TotalDelShares.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalLiquidTokens", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidstaking
				}
				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 ErrInvalidLengthLiquidstaking
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLiquidstaking
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.TotalLiquidTokens.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalRemainingRewards", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidstaking
				}
				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 ErrInvalidLengthLiquidstaking
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLiquidstaking
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.TotalRemainingRewards.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalUnbondingBalance", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidstaking
				}
				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 ErrInvalidLengthLiquidstaking
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLiquidstaking
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.TotalUnbondingBalance.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProxyAccBalance", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLiquidstaking
				}
				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 ErrInvalidLengthLiquidstaking
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLiquidstaking
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ProxyAccBalance.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLiquidstaking(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLiquidstaking
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

var (
	ErrInvalidLengthLiquidstaking        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowLiquidstaking          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupLiquidstaking = fmt.Errorf("proto: unexpected end of group")
)