// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.6
// 	protoc        v5.29.3
// source: gov.proto

package fsm

import (
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	reflect "reflect"
	sync "sync"
	unsafe "unsafe"
)

const (
	// Verify that this generated code is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	// Verify that runtime/protoimpl is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

// *****************************************************************************************************
// This file is auto-generated from source files in `/lib/.proto/*` using Protocol Buffers (protobuf)
//
// Protobuf is a language-neutral, platform-neutral serialization format. It allows users
// to define objects in a way that’s both efficient to store and fast to transmit over the network.
// These definitions are compiled into code that *enables different systems and programming languages
// to communicate in a byte-perfect manner*
//
// To update these structures, make changes to the source .proto files, then recompile
// to regenerate this file.
// These auto-generated files are easily recognized by checking for a `.pb.go` ending
// *****************************************************************************************************
// _
// _
// _
// GovProposalVoteConfig is the configuration for nodes to handle 'governance proposal transactions' like DAO Transfer
// or Change Parameter
type GovProposalVoteConfig int32

const (
	// accept_all is the default mode for 'non-consensus' where all inbound governance proposals are accepted
	GovProposalVoteConfig_ACCEPT_ALL GovProposalVoteConfig = 0
	// approve_list is the default mode for Validators who are active in BFT. This refers to their local approve list in
	// their data directory
	GovProposalVoteConfig_APPROVE_LIST GovProposalVoteConfig = 1
	// reject_all is a mode that turns on if problems are detected during the consensus process, ensuring the proposal
	// process doesn't contribute to a chain halt
	GovProposalVoteConfig_REJECT_ALL GovProposalVoteConfig = 2
)

// Enum value maps for GovProposalVoteConfig.
var (
	GovProposalVoteConfig_name = map[int32]string{
		0: "ACCEPT_ALL",
		1: "APPROVE_LIST",
		2: "REJECT_ALL",
	}
	GovProposalVoteConfig_value = map[string]int32{
		"ACCEPT_ALL":   0,
		"APPROVE_LIST": 1,
		"REJECT_ALL":   2,
	}
)

func (x GovProposalVoteConfig) Enum() *GovProposalVoteConfig {
	p := new(GovProposalVoteConfig)
	*p = x
	return p
}

func (x GovProposalVoteConfig) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (GovProposalVoteConfig) Descriptor() protoreflect.EnumDescriptor {
	return file_gov_proto_enumTypes[0].Descriptor()
}

func (GovProposalVoteConfig) Type() protoreflect.EnumType {
	return &file_gov_proto_enumTypes[0]
}

func (x GovProposalVoteConfig) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use GovProposalVoteConfig.Descriptor instead.
func (GovProposalVoteConfig) EnumDescriptor() ([]byte, []int) {
	return file_gov_proto_rawDescGZIP(), []int{0}
}

// Params are are configurable settings in a blockchain or decentralized network that control various aspects of the
// system's operation and rules, such as transaction fees, block sizes, and validator behaviors. These parameters can be
// adjusted through validator consensus to adapt the network as needs change.
// Parameters are organized into 4 'parameter spaces' that are purely for organization and i/o optimization.
type Params struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// consensus: are parameters in the 'consensus' space
	// settings that define how nodes in the blockchain agree on the state of the ledger
	Consensus *ConsensusParams `protobuf:"bytes,1,opt,name=Consensus,proto3" json:"consensus"` // @gotags: json:"consensus"
	// validator: are parameters in the 'validator' space
	// settings that define the rules and criteria for validators in the blockchain network
	Validator *ValidatorParams `protobuf:"bytes,2,opt,name=Validator,proto3" json:"validator"` // @gotags: json:"validator"
	// fee: are parameters in the 'fee' space
	// settings that define the various amounts of transaction fees
	Fee *FeeParams `protobuf:"bytes,3,opt,name=Fee,proto3" json:"fee"` // @gotags: json:"fee"
	// governance: are parameters in the 'gov' space
	// settings that define the rules that enable decentralized and autonomous governing of the network
	Governance    *GovernanceParams `protobuf:"bytes,4,opt,name=Governance,proto3" json:"governance"` // @gotags: json:"governance"
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Params) Reset() {
	*x = Params{}
	mi := &file_gov_proto_msgTypes[0]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Params) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Params) ProtoMessage() {}

func (x *Params) ProtoReflect() protoreflect.Message {
	mi := &file_gov_proto_msgTypes[0]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Params.ProtoReflect.Descriptor instead.
func (*Params) Descriptor() ([]byte, []int) {
	return file_gov_proto_rawDescGZIP(), []int{0}
}

func (x *Params) GetConsensus() *ConsensusParams {
	if x != nil {
		return x.Consensus
	}
	return nil
}

func (x *Params) GetValidator() *ValidatorParams {
	if x != nil {
		return x.Validator
	}
	return nil
}

func (x *Params) GetFee() *FeeParams {
	if x != nil {
		return x.Fee
	}
	return nil
}

func (x *Params) GetGovernance() *GovernanceParams {
	if x != nil {
		return x.Governance
	}
	return nil
}

// The ProtocolVersion is a string that marks the particular version of rules governing how nodes communicate and
// validate data in a network. It enables nodes to stay synchronized, ensuring they follow the same standards
type ProtocolVersion struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// height: the block number the protocol version becomes live
	Height uint64 `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"`
	// version: is an identifier for a specific set of rules and features in a blockchain or network protocol
	Version       uint64 `protobuf:"varint,2,opt,name=version,proto3" json:"version,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ProtocolVersion) Reset() {
	*x = ProtocolVersion{}
	mi := &file_gov_proto_msgTypes[1]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ProtocolVersion) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ProtocolVersion) ProtoMessage() {}

func (x *ProtocolVersion) ProtoReflect() protoreflect.Message {
	mi := &file_gov_proto_msgTypes[1]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ProtocolVersion.ProtoReflect.Descriptor instead.
func (*ProtocolVersion) Descriptor() ([]byte, []int) {
	return file_gov_proto_rawDescGZIP(), []int{1}
}

func (x *ProtocolVersion) GetHeight() uint64 {
	if x != nil {
		return x.Height
	}
	return 0
}

func (x *ProtocolVersion) GetVersion() uint64 {
	if x != nil {
		return x.Version
	}
	return 0
}

// ConsensusParams is the parameter space that defines how nodes in the blockchain agree on the state of the ledger
type ConsensusParams struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// block_size: is the maximum allowed size of a block (not including the header)
	BlockSize uint64 `protobuf:"varint,1,opt,name=block_size,json=blockSize,proto3" json:"blockSize"` // @gotags: json:"blockSize"
	// protocol_version: is the minimum protocol standard that nodes must run to participate in the network
	ProtocolVersion string `protobuf:"bytes,2,opt,name=protocol_version,json=protocolVersion,proto3" json:"protocolVersion"` // @gotags: json:"protocolVersion"
	// root_chain_id: the identifier of the root chain (source of the validator set)
	RootChainId uint64 `protobuf:"varint,3,opt,name=root_chain_id,json=rootChainId,proto3" json:"rootChainID"` // @gotags: json:"rootChainID"
	// retired: have the validators agreed to stop this chain and mark it as 'forever un-subsidized' in the base chain
	Retired       uint64 `protobuf:"varint,4,opt,name=retired,proto3" json:"retired,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ConsensusParams) Reset() {
	*x = ConsensusParams{}
	mi := &file_gov_proto_msgTypes[2]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ConsensusParams) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ConsensusParams) ProtoMessage() {}

func (x *ConsensusParams) ProtoReflect() protoreflect.Message {
	mi := &file_gov_proto_msgTypes[2]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ConsensusParams.ProtoReflect.Descriptor instead.
func (*ConsensusParams) Descriptor() ([]byte, []int) {
	return file_gov_proto_rawDescGZIP(), []int{2}
}

func (x *ConsensusParams) GetBlockSize() uint64 {
	if x != nil {
		return x.BlockSize
	}
	return 0
}

func (x *ConsensusParams) GetProtocolVersion() string {
	if x != nil {
		return x.ProtocolVersion
	}
	return ""
}

func (x *ConsensusParams) GetRootChainId() uint64 {
	if x != nil {
		return x.RootChainId
	}
	return 0
}

func (x *ConsensusParams) GetRetired() uint64 {
	if x != nil {
		return x.Retired
	}
	return 0
}

// ValidatorParams is the parameter space that defines the rules and criteria for validators in the blockchain
type ValidatorParams struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// unstaking_blocks: is the number of blocks a validator's staked tokens must remain locked and slashable after
	// sending 'unstake_validator'. Without unstaking blocks, validators could withdraw their stake right after attempting
	// malicious behavior, like double-signing or failing to validate correctly
	UnstakingBlocks uint64 `protobuf:"varint,1,opt,name=unstaking_blocks,json=unstakingBlocks,proto3" json:"unstakingBlocks"` // @gotags: json:"unstakingBlocks"
	// max_pause_blocks: is the maximum number of blocks a validator may be paused before being 'force unstaked'.
	// This is necessary to prevent dead validators from forever existing in the state
	MaxPauseBlocks uint64 `protobuf:"varint,2,opt,name=max_pause_blocks,json=maxPauseBlocks,proto3" json:"maxPauseBlocks"` // @gotags: json:"maxPauseBlocks"
	// double_sign_slash_percentage: is the percentage of staked tokens that are slashed when a Validator is caught
	// performing a double-sign (signing two different blocks for the same block height and round,
	// supporting conflicting versions of the blockchain)
	DoubleSignSlashPercentage uint64 `protobuf:"varint,3,opt,name=double_sign_slash_percentage,json=doubleSignSlashPercentage,proto3" json:"doubleSignSlashPercentage"` // @gotags: json:"doubleSignSlashPercentage"
	// non_sign_slash_percentage: is the percentage of staked tokens that are slashed when a Validator doesn't sign a
	// number of blocks over the max_non_sign threshold within the non_sign_window blocks.
	NonSignSlashPercentage uint64 `protobuf:"varint,4,opt,name=non_sign_slash_percentage,json=nonSignSlashPercentage,proto3" json:"nonSignSlashPercentage"` // @gotags: json:"nonSignSlashPercentage"
	// max_non_sign: is the maximum number of blocks a Validator may not sign before being slashed, a threshold system
	// provides lee-way for accidental non-sign faults
	MaxNonSign uint64 `protobuf:"varint,5,opt,name=max_non_sign,json=maxNonSign,proto3" json:"maxNonSign"` // @gotags: json:"maxNonSign"
	// non_sign_window: is the period of blocks in which a validator’s count of missed signatures (non-signs) is tracked
	// before it is reset. During this window, if a validator fails to sign blocks, the missed count is incremented
	// Once the window expires, the non-sign count is reset, providing the validator a chance to recover without immediate
	// penalties
	NonSignWindow uint64 `protobuf:"varint,6,opt,name=non_sign_window,json=nonSignWindow,proto3" json:"nonSignWindow"` // @gotags: json:"nonSignWindow"
	// max_committees: is the maximum number of committees a validator is allowed to stake for
	MaxCommittees uint64 `protobuf:"varint,7,opt,name=max_committees,json=maxCommittees,proto3" json:"maxCommittees"` // @gotags: json:"maxCommittees"
	// max_committee_size: is the maximum number of active validators a committee may have participating in BFT at any
	// one view
	MaxCommitteeSize uint64 `protobuf:"varint,8,opt,name=max_committee_size,json=maxCommitteeSize,proto3" json:"maxCommitteeSize"` // @gotags: json:"maxCommitteeSize"
	// early_withdrawal_penalty: is the percent reward deduction if NOT compounding validator rewards
	EarlyWithdrawalPenalty uint64 `protobuf:"varint,9,opt,name=early_withdrawal_penalty,json=earlyWithdrawalPenalty,proto3" json:"earlyWithdrawalPenalty"` // @gotags: json:"earlyWithdrawalPenalty"
	// delegate_unstaking_blocks: is the number of blocks a delegate validator's staked tokens must remain locked.
	// Since there's no slashing of delegates, this variable affects economic stability more than security
	DelegateUnstakingBlocks uint64 `protobuf:"varint,10,opt,name=delegate_unstaking_blocks,json=delegateUnstakingBlocks,proto3" json:"delegateUnstakingBlocks"` // @gotags: json:"delegateUnstakingBlocks"
	// minimum_order_size: is the minimum amount a 'sell order' must sell in order to be valid
	MinimumOrderSize uint64 `protobuf:"varint,11,opt,name=minimum_order_size,json=minimumOrderSize,proto3" json:"minimumOrderSize"` // @gotags: json:"minimumOrderSize"
	// stake_percent_for_subsidized_committee: is the minimum percentage of total stake that a committee must have
	// committed to it in order to be considered "subsidized" by the protocol
	StakePercentForSubsidizedCommittee uint64 `protobuf:"varint,12,opt,name=stake_percent_for_subsidized_committee,json=stakePercentForSubsidizedCommittee,proto3" json:"stakePercentForSubsidizedCommittee"` // @gotags: json:"stakePercentForSubsidizedCommittee"
	// max_slash_per_committee: is the maximum slash per committee per block that a validator may receive.
	// If the slash exceeds maximum, the validator will be auto-removed from the committee to protect all parties from
	// cascading failures.
	MaxSlashPerCommittee uint64 `protobuf:"varint,13,opt,name=max_slash_per_committee,json=maxSlashPerCommittee,proto3" json:"maxSlashPerCommittee"` // @gotags: json:"maxSlashPerCommittee"
	// delegate_reward_percentage: is the percentage of the block reward that is awarded to the delegates
	DelegateRewardPercentage uint64 `protobuf:"varint,14,opt,name=delegate_reward_percentage,json=delegateRewardPercentage,proto3" json:"delegateRewardPercentage"` // @gotags: json:"delegateRewardPercentage"
	// buy_deadline_blocks: amount of blocks a 'buyer' has to complete an order they 'reserved'
	BuyDeadlineBlocks uint64 `protobuf:"varint,15,opt,name=buy_deadline_blocks,json=buyDeadlineBlocks,proto3" json:"buyDeadlineBlocks"` // @gotags: json:"buyDeadlineBlocks"
	// lock_order_fee_multiplier: the fee multiplier of the 'send' fee that is required to execute a lock order
	LockOrderFeeMultiplier uint64 `protobuf:"varint,16,opt,name=lock_order_fee_multiplier,json=lockOrderFeeMultiplier,proto3" json:"lockOrderFeeMultiplier"` // @gotags: json:"lockOrderFeeMultiplier"
	unknownFields          protoimpl.UnknownFields
	sizeCache              protoimpl.SizeCache
}

func (x *ValidatorParams) Reset() {
	*x = ValidatorParams{}
	mi := &file_gov_proto_msgTypes[3]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ValidatorParams) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ValidatorParams) ProtoMessage() {}

func (x *ValidatorParams) ProtoReflect() protoreflect.Message {
	mi := &file_gov_proto_msgTypes[3]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ValidatorParams.ProtoReflect.Descriptor instead.
func (*ValidatorParams) Descriptor() ([]byte, []int) {
	return file_gov_proto_rawDescGZIP(), []int{3}
}

func (x *ValidatorParams) GetUnstakingBlocks() uint64 {
	if x != nil {
		return x.UnstakingBlocks
	}
	return 0
}

func (x *ValidatorParams) GetMaxPauseBlocks() uint64 {
	if x != nil {
		return x.MaxPauseBlocks
	}
	return 0
}

func (x *ValidatorParams) GetDoubleSignSlashPercentage() uint64 {
	if x != nil {
		return x.DoubleSignSlashPercentage
	}
	return 0
}

func (x *ValidatorParams) GetNonSignSlashPercentage() uint64 {
	if x != nil {
		return x.NonSignSlashPercentage
	}
	return 0
}

func (x *ValidatorParams) GetMaxNonSign() uint64 {
	if x != nil {
		return x.MaxNonSign
	}
	return 0
}

func (x *ValidatorParams) GetNonSignWindow() uint64 {
	if x != nil {
		return x.NonSignWindow
	}
	return 0
}

func (x *ValidatorParams) GetMaxCommittees() uint64 {
	if x != nil {
		return x.MaxCommittees
	}
	return 0
}

func (x *ValidatorParams) GetMaxCommitteeSize() uint64 {
	if x != nil {
		return x.MaxCommitteeSize
	}
	return 0
}

func (x *ValidatorParams) GetEarlyWithdrawalPenalty() uint64 {
	if x != nil {
		return x.EarlyWithdrawalPenalty
	}
	return 0
}

func (x *ValidatorParams) GetDelegateUnstakingBlocks() uint64 {
	if x != nil {
		return x.DelegateUnstakingBlocks
	}
	return 0
}

func (x *ValidatorParams) GetMinimumOrderSize() uint64 {
	if x != nil {
		return x.MinimumOrderSize
	}
	return 0
}

func (x *ValidatorParams) GetStakePercentForSubsidizedCommittee() uint64 {
	if x != nil {
		return x.StakePercentForSubsidizedCommittee
	}
	return 0
}

func (x *ValidatorParams) GetMaxSlashPerCommittee() uint64 {
	if x != nil {
		return x.MaxSlashPerCommittee
	}
	return 0
}

func (x *ValidatorParams) GetDelegateRewardPercentage() uint64 {
	if x != nil {
		return x.DelegateRewardPercentage
	}
	return 0
}

func (x *ValidatorParams) GetBuyDeadlineBlocks() uint64 {
	if x != nil {
		return x.BuyDeadlineBlocks
	}
	return 0
}

func (x *ValidatorParams) GetLockOrderFeeMultiplier() uint64 {
	if x != nil {
		return x.LockOrderFeeMultiplier
	}
	return 0
}

// FeeParams is the parameter space that defines various amounts for transaction fees
type FeeParams struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// send_fee: is the fee amount (in uCNPY) for Message Send
	SendFee uint64 `protobuf:"varint,1,opt,name=send_fee,json=sendFee,proto3" json:"sendFee"` // @gotags: json:"sendFee"
	// stake_fee: is the fee amount (in uCNPY) for Message Stake
	StakeFee uint64 `protobuf:"varint,2,opt,name=stake_fee,json=stakeFee,proto3" json:"stakeFee"` // @gotags: json:"stakeFee"
	// edit_stake_fee: is the fee amount (in uCNPY) for Message Edit-Stake
	EditStakeFee uint64 `protobuf:"varint,3,opt,name=edit_stake_fee,json=editStakeFee,proto3" json:"editStakeFee"` // @gotags: json:"editStakeFee"
	// unstake_stake_fee: is the fee amount (in uCNPY) for Message Unstake
	UnstakeFee uint64 `protobuf:"varint,4,opt,name=unstake_fee,json=unstakeFee,proto3" json:"unstakeFee"` // @gotags: json:"unstakeFee"
	// pause_fee: is the fee amount (in uCNPY) for Message Pause
	PauseFee uint64 `protobuf:"varint,5,opt,name=pause_fee,json=pauseFee,proto3" json:"pauseFee"` // @gotags: json:"pauseFee"
	// unpause_fee: is the fee amount (in uCNPY) for Message Unpause
	UnpauseFee uint64 `protobuf:"varint,6,opt,name=unpause_fee,json=unpauseFee,proto3" json:"unpauseFee"` // @gotags: json:"unpauseFee"
	// change_parameter_fee: is the fee amount (in uCNPY) for Message Change Parameter
	ChangeParameterFee uint64 `protobuf:"varint,7,opt,name=change_parameter_fee,json=changeParameterFee,proto3" json:"changeParameterFee"` // @gotags: json:"changeParameterFee"
	// dao_transfer: is the fee amount (in uCNPY) for Message DAO transfer
	DaoTransferFee uint64 `protobuf:"varint,8,opt,name=dao_transfer_fee,json=daoTransferFee,proto3" json:"daoTransferFee"` // @gotags: json:"daoTransferFee"
	// certificate_results_fee: is the fee amount (in uCNPY) for Message Certificate Results
	CertificateResultsFee uint64 `protobuf:"varint,9,opt,name=certificate_results_fee,json=certificateResultsFee,proto3" json:"certificateResultsFee"` // @gotags: json:"certificateResultsFee"
	// subsidy_fee: is the fee amount (in uCNPY) for Message Subsidy
	SubsidyFee uint64 `protobuf:"varint,10,opt,name=subsidy_fee,json=subsidyFee,proto3" json:"subsidyFee"` // @gotags: json:"subsidyFee"
	// create_order_fee: is the fee amount (in uCNPY) for Message Create Order
	CreateOrderFee uint64 `protobuf:"varint,11,opt,name=create_order_fee,json=createOrderFee,proto3" json:"createOrderFee"` // @gotags: json:"createOrderFee"
	// edit_order_fee: is the fee amount (in uCNPY) for Message Edit Order
	EditOrderFee uint64 `protobuf:"varint,12,opt,name=edit_order_fee,json=editOrderFee,proto3" json:"editOrderFee"` // @gotags: json:"editOrderFee"
	// delete_order_fee: is the fee amount (in uCNPY) for Message Delete Order
	DeleteOrderFee uint64 `protobuf:"varint,13,opt,name=delete_order_fee,json=deleteOrderFee,proto3" json:"deleteOrderFee"` // @gotags: json:"deleteOrderFee"
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *FeeParams) Reset() {
	*x = FeeParams{}
	mi := &file_gov_proto_msgTypes[4]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *FeeParams) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*FeeParams) ProtoMessage() {}

func (x *FeeParams) ProtoReflect() protoreflect.Message {
	mi := &file_gov_proto_msgTypes[4]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use FeeParams.ProtoReflect.Descriptor instead.
func (*FeeParams) Descriptor() ([]byte, []int) {
	return file_gov_proto_rawDescGZIP(), []int{4}
}

func (x *FeeParams) GetSendFee() uint64 {
	if x != nil {
		return x.SendFee
	}
	return 0
}

func (x *FeeParams) GetStakeFee() uint64 {
	if x != nil {
		return x.StakeFee
	}
	return 0
}

func (x *FeeParams) GetEditStakeFee() uint64 {
	if x != nil {
		return x.EditStakeFee
	}
	return 0
}

func (x *FeeParams) GetUnstakeFee() uint64 {
	if x != nil {
		return x.UnstakeFee
	}
	return 0
}

func (x *FeeParams) GetPauseFee() uint64 {
	if x != nil {
		return x.PauseFee
	}
	return 0
}

func (x *FeeParams) GetUnpauseFee() uint64 {
	if x != nil {
		return x.UnpauseFee
	}
	return 0
}

func (x *FeeParams) GetChangeParameterFee() uint64 {
	if x != nil {
		return x.ChangeParameterFee
	}
	return 0
}

func (x *FeeParams) GetDaoTransferFee() uint64 {
	if x != nil {
		return x.DaoTransferFee
	}
	return 0
}

func (x *FeeParams) GetCertificateResultsFee() uint64 {
	if x != nil {
		return x.CertificateResultsFee
	}
	return 0
}

func (x *FeeParams) GetSubsidyFee() uint64 {
	if x != nil {
		return x.SubsidyFee
	}
	return 0
}

func (x *FeeParams) GetCreateOrderFee() uint64 {
	if x != nil {
		return x.CreateOrderFee
	}
	return 0
}

func (x *FeeParams) GetEditOrderFee() uint64 {
	if x != nil {
		return x.EditOrderFee
	}
	return 0
}

func (x *FeeParams) GetDeleteOrderFee() uint64 {
	if x != nil {
		return x.DeleteOrderFee
	}
	return 0
}

// GovernanceParams is the parameter space that define the rules that enable decentralized and autonomous
// governing of the network
type GovernanceParams struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// dao_reward_percent: is the percent of the block reward that is sent to the DAO
	DaoRewardPercentage uint64 `protobuf:"varint,1,opt,name=dao_reward_percentage,json=daoRewardPercentage,proto3" json:"daoRewardPercentage"` // @gotags: json:"daoRewardPercentage"
	unknownFields       protoimpl.UnknownFields
	sizeCache           protoimpl.SizeCache
}

func (x *GovernanceParams) Reset() {
	*x = GovernanceParams{}
	mi := &file_gov_proto_msgTypes[5]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *GovernanceParams) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*GovernanceParams) ProtoMessage() {}

func (x *GovernanceParams) ProtoReflect() protoreflect.Message {
	mi := &file_gov_proto_msgTypes[5]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use GovernanceParams.ProtoReflect.Descriptor instead.
func (*GovernanceParams) Descriptor() ([]byte, []int) {
	return file_gov_proto_rawDescGZIP(), []int{5}
}

func (x *GovernanceParams) GetDaoRewardPercentage() uint64 {
	if x != nil {
		return x.DaoRewardPercentage
	}
	return 0
}

var File_gov_proto protoreflect.FileDescriptor

const file_gov_proto_rawDesc = "" +
	"\n" +
	"\tgov.proto\x12\x05types\"\xd1\x01\n" +
	"\x06Params\x124\n" +
	"\tConsensus\x18\x01 \x01(\v2\x16.types.ConsensusParamsR\tConsensus\x124\n" +
	"\tValidator\x18\x02 \x01(\v2\x16.types.ValidatorParamsR\tValidator\x12\"\n" +
	"\x03Fee\x18\x03 \x01(\v2\x10.types.FeeParamsR\x03Fee\x127\n" +
	"\n" +
	"Governance\x18\x04 \x01(\v2\x17.types.GovernanceParamsR\n" +
	"Governance\"C\n" +
	"\x0fProtocolVersion\x12\x16\n" +
	"\x06height\x18\x01 \x01(\x04R\x06height\x12\x18\n" +
	"\aversion\x18\x02 \x01(\x04R\aversion\"\x99\x01\n" +
	"\x0fConsensusParams\x12\x1d\n" +
	"\n" +
	"block_size\x18\x01 \x01(\x04R\tblockSize\x12)\n" +
	"\x10protocol_version\x18\x02 \x01(\tR\x0fprotocolVersion\x12\"\n" +
	"\rroot_chain_id\x18\x03 \x01(\x04R\vrootChainId\x12\x18\n" +
	"\aretired\x18\x04 \x01(\x04R\aretired\"\xd9\x06\n" +
	"\x0fValidatorParams\x12)\n" +
	"\x10unstaking_blocks\x18\x01 \x01(\x04R\x0funstakingBlocks\x12(\n" +
	"\x10max_pause_blocks\x18\x02 \x01(\x04R\x0emaxPauseBlocks\x12?\n" +
	"\x1cdouble_sign_slash_percentage\x18\x03 \x01(\x04R\x19doubleSignSlashPercentage\x129\n" +
	"\x19non_sign_slash_percentage\x18\x04 \x01(\x04R\x16nonSignSlashPercentage\x12 \n" +
	"\fmax_non_sign\x18\x05 \x01(\x04R\n" +
	"maxNonSign\x12&\n" +
	"\x0fnon_sign_window\x18\x06 \x01(\x04R\rnonSignWindow\x12%\n" +
	"\x0emax_committees\x18\a \x01(\x04R\rmaxCommittees\x12,\n" +
	"\x12max_committee_size\x18\b \x01(\x04R\x10maxCommitteeSize\x128\n" +
	"\x18early_withdrawal_penalty\x18\t \x01(\x04R\x16earlyWithdrawalPenalty\x12:\n" +
	"\x19delegate_unstaking_blocks\x18\n" +
	" \x01(\x04R\x17delegateUnstakingBlocks\x12,\n" +
	"\x12minimum_order_size\x18\v \x01(\x04R\x10minimumOrderSize\x12R\n" +
	"&stake_percent_for_subsidized_committee\x18\f \x01(\x04R\"stakePercentForSubsidizedCommittee\x125\n" +
	"\x17max_slash_per_committee\x18\r \x01(\x04R\x14maxSlashPerCommittee\x12<\n" +
	"\x1adelegate_reward_percentage\x18\x0e \x01(\x04R\x18delegateRewardPercentage\x12.\n" +
	"\x13buy_deadline_blocks\x18\x0f \x01(\x04R\x11buyDeadlineBlocks\x129\n" +
	"\x19lock_order_fee_multiplier\x18\x10 \x01(\x04R\x16lockOrderFeeMultiplier\"\xf7\x03\n" +
	"\tFeeParams\x12\x19\n" +
	"\bsend_fee\x18\x01 \x01(\x04R\asendFee\x12\x1b\n" +
	"\tstake_fee\x18\x02 \x01(\x04R\bstakeFee\x12$\n" +
	"\x0eedit_stake_fee\x18\x03 \x01(\x04R\feditStakeFee\x12\x1f\n" +
	"\vunstake_fee\x18\x04 \x01(\x04R\n" +
	"unstakeFee\x12\x1b\n" +
	"\tpause_fee\x18\x05 \x01(\x04R\bpauseFee\x12\x1f\n" +
	"\vunpause_fee\x18\x06 \x01(\x04R\n" +
	"unpauseFee\x120\n" +
	"\x14change_parameter_fee\x18\a \x01(\x04R\x12changeParameterFee\x12(\n" +
	"\x10dao_transfer_fee\x18\b \x01(\x04R\x0edaoTransferFee\x126\n" +
	"\x17certificate_results_fee\x18\t \x01(\x04R\x15certificateResultsFee\x12\x1f\n" +
	"\vsubsidy_fee\x18\n" +
	" \x01(\x04R\n" +
	"subsidyFee\x12(\n" +
	"\x10create_order_fee\x18\v \x01(\x04R\x0ecreateOrderFee\x12$\n" +
	"\x0eedit_order_fee\x18\f \x01(\x04R\feditOrderFee\x12(\n" +
	"\x10delete_order_fee\x18\r \x01(\x04R\x0edeleteOrderFee\"F\n" +
	"\x10GovernanceParams\x122\n" +
	"\x15dao_reward_percentage\x18\x01 \x01(\x04R\x13daoRewardPercentage*I\n" +
	"\x15GovProposalVoteConfig\x12\x0e\n" +
	"\n" +
	"ACCEPT_ALL\x10\x00\x12\x10\n" +
	"\fAPPROVE_LIST\x10\x01\x12\x0e\n" +
	"\n" +
	"REJECT_ALL\x10\x02B&Z$github.com/canopy-network/canopy/fsmb\x06proto3"

var (
	file_gov_proto_rawDescOnce sync.Once
	file_gov_proto_rawDescData []byte
)

func file_gov_proto_rawDescGZIP() []byte {
	file_gov_proto_rawDescOnce.Do(func() {
		file_gov_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_gov_proto_rawDesc), len(file_gov_proto_rawDesc)))
	})
	return file_gov_proto_rawDescData
}

var file_gov_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
var file_gov_proto_msgTypes = make([]protoimpl.MessageInfo, 6)
var file_gov_proto_goTypes = []any{
	(GovProposalVoteConfig)(0), // 0: types.GovProposalVoteConfig
	(*Params)(nil),             // 1: types.Params
	(*ProtocolVersion)(nil),    // 2: types.ProtocolVersion
	(*ConsensusParams)(nil),    // 3: types.ConsensusParams
	(*ValidatorParams)(nil),    // 4: types.ValidatorParams
	(*FeeParams)(nil),          // 5: types.FeeParams
	(*GovernanceParams)(nil),   // 6: types.GovernanceParams
}
var file_gov_proto_depIdxs = []int32{
	3, // 0: types.Params.Consensus:type_name -> types.ConsensusParams
	4, // 1: types.Params.Validator:type_name -> types.ValidatorParams
	5, // 2: types.Params.Fee:type_name -> types.FeeParams
	6, // 3: types.Params.Governance:type_name -> types.GovernanceParams
	4, // [4:4] is the sub-list for method output_type
	4, // [4:4] is the sub-list for method input_type
	4, // [4:4] is the sub-list for extension type_name
	4, // [4:4] is the sub-list for extension extendee
	0, // [0:4] is the sub-list for field type_name
}

func init() { file_gov_proto_init() }
func file_gov_proto_init() {
	if File_gov_proto != nil {
		return
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_gov_proto_rawDesc), len(file_gov_proto_rawDesc)),
			NumEnums:      1,
			NumMessages:   6,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_gov_proto_goTypes,
		DependencyIndexes: file_gov_proto_depIdxs,
		EnumInfos:         file_gov_proto_enumTypes,
		MessageInfos:      file_gov_proto_msgTypes,
	}.Build()
	File_gov_proto = out.File
	file_gov_proto_goTypes = nil
	file_gov_proto_depIdxs = nil
}
